all

Author: rubenfiszel

debugger/dap_debug_service.ts

@@ -162,13 +162,19 @@ function spawnProcess(options: SpawnOptions): Subprocess {
 		logger.info(`Spawning: ${cmd.join(' ')}`)
 	}
 
+	// Only include essential env vars + caller-provided ones
+	// Don't inherit all of process.env to keep debugger environment clean
 	return spawn({
 		cmd,
 		cwd: options.cwd || process.cwd(),
 		stdout: options.stdout || 'pipe',
 		stderr: options.stderr || 'pipe',
 		env: {
-			...process.env,
+			// Essential system vars
+			PATH: process.env.PATH || '/usr/bin:/bin',
+			HOME: process.env.HOME,
+			// Caller-provided env vars
+			// Note: WM_BASE_URL is already overridden by BASE_INTERNAL_URL if set
 			...options.env
 		}
 	})
@@ -270,6 +276,7 @@ class PythonDebugSession extends BaseDebugSession {
 	private variablesRefCounter = 1
 	private scopesMap = new Map<number, { variablesReference: number }>()
 	private scriptResult: unknown = undefined
+	private envVars: Record<string, string> = {}
 
 	private nextDebugpySeq(): number {
 		return this.debugpySeq++
@@ -399,6 +406,7 @@ class PythonDebugSession extends BaseDebugSession {
 		const scriptDir = import.meta.dir
 
 		// Spawn the Python WebSocket DAP server
+		// Pass env vars to the server - it will forward them to the debugged script
 		this.process = spawnProcess({
 			cmd: [
 				config.pythonPath,
@@ -408,7 +416,7 @@ class PythonDebugSession extends BaseDebugSession {
 				'--host', '127.0.0.1'
 			],
 			cwd,
-			env: { PYTHONUNBUFFERED: '1' }
+			env: { PYTHONUNBUFFERED: '1', ...this.envVars }
 		})
 
 		// Read stderr to capture startup messages
@@ -643,6 +651,16 @@ class PythonDebugSession extends BaseDebugSession {
 		const cwd = (args.cwd as string) || process.cwd()
 		this.callMain = (args.callMain as boolean) || false
 		this.mainArgs = (args.args as Record<string, unknown>) || {}
+		this.envVars = (args.env as Record<string, string>) || {}
+
+		// If BASE_INTERNAL_URL is set on the server, use it to override WM_BASE_URL
+		if (process.env.BASE_INTERNAL_URL) {
+			this.envVars.WM_BASE_URL = process.env.BASE_INTERNAL_URL
+		}
+
+		if (Object.keys(this.envVars).length > 0) {
+			logger.info(`Python launch with env vars: ${Object.keys(this.envVars).join(', ')}`)
+		}
 
 		if (!this.scriptPath && !code) {
 			this.sendResponse(request, false, {}, 'No program or code specified')
@@ -699,7 +717,8 @@ sys.stdout.flush()
 				code: code,
 				args: this.mainArgs,
 				cwd: cwd,
-				callMain: this.callMain
+				callMain: this.callMain,
+				env: this.envVars
 			})
 		} catch (error) {
 			this.sendEvent('output', { category: 'stderr', output: `Failed to start Python: ${error}\n` })

debugger/dap_websocket_server.py

@@ -425,6 +425,10 @@ async def handle_launch(self, request: dict) -> None:
         cwd = args.get("cwd", os.getcwd())
         self._call_main = args.get("callMain", False)
         self._main_args = args.get("args", {})
+        self._env_vars = args.get("env", {})
+
+        if self._env_vars:
+            logger.info(f"Launch with env vars: {list(self._env_vars.keys())}")
 
         if not self.script_path and not code:
             await self.send_response(
@@ -486,6 +490,14 @@ def _run_script(self, script_path: str, cwd: str) -> None:
         old_argv = sys.argv
         old_stdout = sys.stdout
         old_stderr = sys.stderr
+        old_env = {}
+
+        # Set environment variables for the script
+        if hasattr(self, '_env_vars') and self._env_vars:
+            for key, value in self._env_vars.items():
+                old_env[key] = os.environ.get(key)
+                os.environ[key] = str(value)
+            logger.info(f"Set {len(self._env_vars)} env vars for script")
 
         # Create a streaming output wrapper that sends output events in real-time
         session = self
@@ -573,6 +585,12 @@ def flush(self):
             sys.argv = old_argv
             sys.stdout = old_stdout
             sys.stderr = old_stderr
+            # Restore environment variables
+            for key, old_value in old_env.items():
+                if old_value is None:
+                    os.environ.pop(key, None)
+                else:
+                    os.environ[key] = old_value
             self._cleanup_temp_file()
 
     def _cleanup_temp_file(self) -> None:

debugger/dap_websocket_server_bun.ts

@@ -298,6 +298,9 @@ export class DebugSession {
 	// Track if current pause is due to a breakpoint (for line number correction)
 	private pausedAtBreakpoint = false
 
+	// Environment variables to pass to the debugger subprocess (e.g., WM_WORKSPACE, WM_TOKEN, etc.)
+	private envVars: Record<string, string> = {}
+
 	// Nsjail configuration for sandboxed execution
 	private nsjailConfig?: NsjailConfig
 
@@ -704,6 +707,83 @@ export class DebugSession {
 		})
 	}
 
+	/**
+	 * Format a console parameter for output.
+	 * Handles primitives, objects with preview, arrays, etc.
+	 */
+	private formatConsoleParameter(p: {
+		type: string
+		value?: unknown
+		description?: string
+		subtype?: string
+		className?: string
+		objectId?: string
+		preview?: {
+			type: string
+			subtype?: string
+			description?: string
+			overflow?: boolean
+			properties?: Array<{ name: string; type: string; value?: string; subtype?: string }>
+		}
+	}): string {
+		// Handle primitives with direct values
+		if (p.value !== undefined) {
+			if (typeof p.value === 'string') return p.value
+			return String(p.value)
+		}
+
+		// Handle null
+		if (p.subtype === 'null') return 'null'
+
+		// Handle undefined
+		if (p.type === 'undefined') return 'undefined'
+
+		// Handle objects with preview (this is the key fix for process.env, etc.)
+		if (p.type === 'object' && p.preview && p.preview.properties) {
+			const props = p.preview.properties
+			const isArray = p.subtype === 'array' || p.preview.subtype === 'array'
+
+			if (isArray) {
+				// Format as array: [val1, val2, ...]
+				const items = props.map((prop) => this.formatPreviewValue(prop))
+				const suffix = p.preview.overflow ? ', ...' : ''
+				return `[${items.join(', ')}${suffix}]`
+			} else {
+				// Format as object: { key1: val1, key2: val2, ... }
+				const items = props.map((prop) => `${prop.name}: ${this.formatPreviewValue(prop)}`)
+				const suffix = p.preview.overflow ? ', ...' : ''
+				return `{ ${items.join(', ')}${suffix} }`
+			}
+		}
+
+		// Handle functions
+		if (p.type === 'function') {
+			return p.description || '[Function]'
+		}
+
+		// Fallback to description (for other object types without preview)
+		if (p.description) return p.description
+
+		return ''
+	}
+
+	/**
+	 * Format a single property from an object preview.
+	 */
+	private formatPreviewValue(prop: { name: string; type: string; value?: string; subtype?: string }): string {
+		if (prop.subtype === 'null') return 'null'
+		if (prop.type === 'undefined') return 'undefined'
+		if (prop.type === 'string') return `"${prop.value ?? ''}"`
+		if (prop.type === 'number' || prop.type === 'boolean') return prop.value ?? ''
+		if (prop.type === 'function') return '[Function]'
+		if (prop.type === 'object') {
+			// Nested objects just show their type/value preview
+			if (prop.subtype === 'array') return prop.value || '[]'
+			return prop.value || '{...}'
+		}
+		return prop.value ?? ''
+	}
+
 	/**
 	 * Handle console output (WebKit/Bun format - Console.messageAdded).
 	 */
@@ -716,19 +796,29 @@ export class DebugSession {
 			line?: number
 			column?: number
 			url?: string
-			parameters?: Array<{ type: string; value?: unknown; description?: string }>
+			parameters?: Array<{
+				type: string
+				value?: unknown
+				description?: string
+				subtype?: string
+				className?: string
+				objectId?: string
+				preview?: {
+					type: string
+					subtype?: string
+					description?: string
+					overflow?: boolean
+					properties?: Array<{ name: string; type: string; value?: string; subtype?: string }>
+				}
+			}>
 		}
 
 		if (!message) return
 
 		let output: string
 		if (message.parameters && message.parameters.length > 0) {
 			output = message.parameters
-				.map((p) => {
-					if (p.value !== undefined) return String(p.value)
-					if (p.description) return p.description
-					return ''
-				})
+				.map((p) => this.formatConsoleParameter(p))
 				.join(' ')
 		} else {
 			output = message.text || ''
@@ -906,6 +996,16 @@ export class DebugSession {
 		const cwd = (args.cwd as string) || process.cwd()
 		this.callMain = (args.callMain as boolean) || false
 		this.mainArgs = (args.args as Record<string, unknown>) || {}
+		this.envVars = (args.env as Record<string, string>) || {}
+
+		// If BASE_INTERNAL_URL is set on the server, use it to override WM_BASE_URL
+		if (process.env.BASE_INTERNAL_URL) {
+			this.envVars.WM_BASE_URL = process.env.BASE_INTERNAL_URL
+		}
+
+		if (Object.keys(this.envVars).length > 0) {
+			logger.info(`Launch with env vars: ${Object.keys(this.envVars).join(', ')}`)
+		}
 
 		if (!this.scriptPath && !code) {
 			this.sendResponse(request, false, {}, 'No program or code specified')
@@ -1017,14 +1117,20 @@ export class DebugSession {
 			}, 10000)
 		})
 
+		// Only include essential env vars + client-provided ones
+		// Don't inherit all of process.env to keep debugger environment clean
 		this.process = spawn({
 			cmd,
 			cwd,
 			stdout: 'pipe',
 			stderr: 'pipe',
 			env: {
-				...process.env,
-				NODE_ENV: 'development'
+				// Essential system vars
+				PATH: process.env.PATH || '/usr/bin:/bin',
+				HOME: process.env.HOME,
+				// Client-provided env vars (WM_WORKSPACE, WM_TOKEN, etc.)
+				// Note: WM_BASE_URL is already overridden by BASE_INTERNAL_URL if set
+				...this.envVars
 			}
 		})
 
@@ -1385,6 +1491,14 @@ export class DebugSession {
 					description?: string
 					objectId?: string
 					subtype?: string
+					className?: string
+					preview?: {
+						type: string
+						subtype?: string
+						description?: string
+						overflow?: boolean
+						properties?: Array<{ name: string; type: string; value?: string; subtype?: string }>
+					}
 				}
 				configurable?: boolean
 				enumerable?: boolean
@@ -1424,7 +1538,7 @@ export class DebugSession {
 				let value: string
 				let varRef = 0
 				let displayType = prop.value.type
-				const className = (prop.value as { className?: string }).className
+				const className = prop.value.className
 
 				// Log for debugging variable parsing issues
 				logger.debug(`Variable ${prop.name}: type=${prop.value.type}, className=${className}, description=${prop.value.description}, value=${JSON.stringify(prop.value.value)}`)
@@ -1445,7 +1559,22 @@ export class DebugSession {
 						// Regular object - create a reference for nested inspection
 						varRef = this.nextVarRef()
 						this.objectsMap.set(varRef, prop.value.objectId)
-						value = prop.value.description || `[${prop.value.subtype || className || 'Object'}]`
+						// Use preview data to show object contents instead of just "Object"
+						if (prop.value.preview && prop.value.preview.properties) {
+							const previewProps = prop.value.preview.properties
+							const isArray = prop.value.subtype === 'array' || prop.value.preview.subtype === 'array'
+							if (isArray) {
+								const items = previewProps.map((p) => this.formatPreviewValue(p))
+								const suffix = prop.value.preview.overflow ? ', ...' : ''
+								value = `[${items.join(', ')}${suffix}]`
+							} else {
+								const items = previewProps.map((p) => `${p.name}: ${this.formatPreviewValue(p)}`)
+								const suffix = prop.value.preview.overflow ? ', ...' : ''
+								value = `{ ${items.join(', ')}${suffix} }`
+							}
+						} else {
+							value = prop.value.description || `[${prop.value.subtype || className || 'Object'}]`
+						}
 					}
 				} else if (prop.value.type === 'string') {
 					// Handle primitive strings - they have value property