refactor(theia): use invalid-response reason for non-record bridge replies

Codex follow-up nit on the previous commit: the union member
'invalid-response' was reachable in theiaEnvironment's switch but the
reader never actually returned it (string responses fell through to
'timeout' after the polling loop). The arktype validation string the
bridge emits when called with the wrong shape will not change between
polls, so polling for 10s is wasted time.

Now: non-record / non-array responses (string, array, primitive) cause
an immediate fail-fast return of 'invalid-response' with the actual
response captured for diagnostics. Genuine timeouts (empty record or
thrown errors throughout) still return 'timeout'.

Author: Predixx

extension/src/extension/theia/dataBridgeReader.ts

@@ -84,7 +84,7 @@ export async function readEnvVarsViaDataBridge<T extends string>(
 
     logger.info('DataBridge enabled, polling for environment variables...', LogCategory.GENERAL);
     const deadline = Date.now() + POLL_TIMEOUT_MS;
-    let lastInvalidResponse: string | undefined;
+    let lastError: string | undefined;
 
     while (Date.now() < deadline) {
         try {
@@ -97,7 +97,7 @@ export async function readEnvVarsViaDataBridge<T extends string>(
                 [...names],
             );
 
-            if (envMap && typeof envMap === 'object') {
+            if (envMap && typeof envMap === 'object' && !Array.isArray(envMap)) {
                 if (names.every((name) => !!(envMap as Record<string, string>)[name])) {
                     logger.info('DataBridge: all environment variables received', LogCategory.GENERAL);
                     const result = {} as Record<T, string | undefined>;
@@ -106,15 +106,23 @@ export async function readEnvVarsViaDataBridge<T extends string>(
                     }
                     return { kind: 'success', env: result };
                 }
-            } else if (typeof envMap === 'string') {
-                // Bridge returned its error summary string — keep the latest
-                // for diagnostics if the deadline runs out before recovery.
-                lastInvalidResponse = envMap;
+                // Record present but missing keys — keep polling; values may
+                // arrive in a later POST.
+            } else if (envMap !== undefined && envMap !== null) {
+                // Non-record response (string, array, primitive). The bridge is
+                // responding but rejecting the call, so polling will not help —
+                // the request shape is wrong and won't change. Fail fast with
+                // the actual response captured for diagnostics.
+                return {
+                    kind: 'failure',
+                    reason: 'invalid-response',
+                    details: typeof envMap === 'string' ? envMap : `unexpected response type: ${typeof envMap}`,
+                };
             }
         } catch (e) {
             // data-bridge may not be ready yet — keep polling. Capture the
             // most recent error to surface if the deadline elapses.
-            lastInvalidResponse = e instanceof Error ? e.message : String(e);
+            lastError = e instanceof Error ? e.message : String(e);
         }
 
         await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
@@ -124,7 +132,7 @@ export async function readEnvVarsViaDataBridge<T extends string>(
         'DataBridge: timeout waiting for environment variables',
         LogCategory.GENERAL,
     );
-    return { kind: 'failure', reason: 'timeout', details: lastInvalidResponse };
+    return { kind: 'failure', reason: 'timeout', details: lastError };
 }
 
 interface DataBridgeProbeResult {

extension/test/unit/theia/dataBridgeReader.test.ts

@@ -90,30 +90,36 @@ suite('readEnvVarsViaDataBridge', () => {
         assert.ok(setTimeoutStub.callCount >= 1);
     });
 
-    test('returns failure with reason=timeout and details when bridge returns its error string', async () => {
+    test('returns failure with reason=invalid-response when bridge returns a string error', async () => {
         process.env.DATA_BRIDGE_ENABLED = '1';
         sandbox.stub(vscode.commands, 'getCommands').resolves(['dataBridge.getEnv']);
         sandbox.stub(vscode.commands, 'executeCommand').resolves('arktype validation error: expected string[]');
 
-        const startTime = 1_000_000_000;
-        let nowOffset = 0;
-        sandbox.stub(Date, 'now').callsFake(() => startTime + nowOffset);
-        sandbox.stub(global, 'setTimeout').callsFake((fn: TimerHandler) => {
-            nowOffset += 11_000;
-            if (typeof fn === 'function') { (fn as () => void)(); }
-            return 0 as unknown as NodeJS.Timeout;
-        });
-
+        // No setTimeout/Date stubs needed — the function should fail fast on
+        // the first non-record response without polling further.
         const result = await readEnvVarsViaDataBridge(KEYS);
 
         assert.strictEqual(result.kind, 'failure');
         if (result.kind === 'failure') {
-            assert.strictEqual(result.reason, 'timeout');
+            assert.strictEqual(result.reason, 'invalid-response');
             assert.ok(result.details && result.details.includes('arktype'),
                 `expected details to include the bridge error string, got: ${result.details}`);
         }
     });
 
+    test('returns failure with reason=invalid-response when bridge returns an array', async () => {
+        process.env.DATA_BRIDGE_ENABLED = '1';
+        sandbox.stub(vscode.commands, 'getCommands').resolves(['dataBridge.getEnv']);
+        sandbox.stub(vscode.commands, 'executeCommand').resolves(['unexpected'] as unknown as Record<string, string>);
+
+        const result = await readEnvVarsViaDataBridge(KEYS);
+
+        assert.strictEqual(result.kind, 'failure');
+        if (result.kind === 'failure') {
+            assert.strictEqual(result.reason, 'invalid-response');
+        }
+    });
+
     test('returns success with all requested keys when bridge delivers them', async () => {
         process.env.DATA_BRIDGE_ENABLED = '1';
         sandbox.stub(vscode.commands, 'getCommands').resolves(['dataBridge.getEnv']);