feat: add shell integration-based terminal output capture for remote environments

When the extension host runs on Windows with a remote workspace (SSH, WSL,
Dev Container), childProcess.spawn executes locally instead of on the remote.
The existing fallback used ide.runCommand (sendText) which had no output
capture, returning a hardcoded "Command failed" status.

This adds a new runCommandWithOutput IDE method that uses VS Code's Shell
Integration API (1.93+) to execute commands on remote terminals with full
output capture. The method creates an invisible terminal, waits for shell
integration to activate, executes via shellIntegration.executeCommand(),
and reads output via the async iterable read() API. ANSI color codes are
preserved for rendering by the UnifiedTerminal component; only VS Code's
internal OSC 633 shell integration markers are stripped.

Falls back gracefully to sendText when shell integration is unavailable.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: shanevcantwell

core/config/types.ts

@@ -691,7 +691,9 @@ declare global {
     getExternalUri?(uri: string): Promise<string>;
   
     runCommand(command: string): Promise<void>;
-  
+
+    runCommandWithOutput(command: string, cwd?: string): Promise<string>;
+
     saveFile(filepath: string): Promise<void>;
   
     readFile(filepath: string): Promise<string>;

core/index.d.ts

@@ -872,6 +872,8 @@ export interface IDE {
 
   runCommand(command: string, options?: TerminalOptions): Promise<void>;
 
+  runCommandWithOutput(command: string, cwd?: string): Promise<string>;
+
   saveFile(fileUri: string): Promise<void>;
 
   readFile(fileUri: string): Promise<string>;

core/protocol/ide.ts

@@ -30,6 +30,7 @@ export type ToIdeFromWebviewOrCoreProtocol = {
   openFile: [{ path: string }, void];
   openUrl: [string, void];
   runCommand: [{ command: string; options?: TerminalOptions }, void];
+  runCommandWithOutput: [{ command: string; cwd?: string }, string];
   getSearchResults: [{ query: string; maxResults?: number }, string];
   getFileResults: [{ pattern: string; maxResults?: number }, string[]];
   subprocess: [{ command: string; cwd?: string }, [string, string]];

core/protocol/messenger/messageIde.ts

@@ -188,6 +188,10 @@ export class MessageIde implements IDE {
     await this.request("runCommand", { command, options });
   }
 
+  async runCommandWithOutput(command: string, cwd?: string): Promise<string> {
+    return this.request("runCommandWithOutput", { command, cwd });
+  }
+
   async saveFile(fileUri: string): Promise<void> {
     await this.request("saveFile", { filepath: fileUri });
   }

core/protocol/messenger/reverseMessageIde.ts

@@ -134,6 +134,10 @@ export class ReverseMessageIde {
       return this.ide.runCommand(data.command);
     });
 
+    this.on("runCommandWithOutput", (data) => {
+      return this.ide.runCommandWithOutput(data.command, data.cwd);
+    });
+
     this.on("saveFile", (data) => {
       return this.ide.saveFile(data.filepath);
     });

core/tools/implementations/runTerminalCommand.ts

@@ -453,16 +453,48 @@ export const runTerminalCommandImpl: ToolImpl = async (args, extras) => {
     }
   }
 
-  // For remote environments, just run the command
-  // Note: waitForCompletion is not supported in remote environments yet
+  // For remote environments, use shell integration for output capture
+  const workspaceDirs = await extras.ide.getWorkspaceDirs();
+  const cwd = workspaceDirs.length > 0 ? workspaceDirs[0] : undefined;
+
+  if (extras.onPartialOutput) {
+    extras.onPartialOutput({
+      toolCallId,
+      contextItems: [
+        {
+          name: "Terminal",
+          description: "Terminal command output",
+          content: "",
+          status: "Running command on remote...",
+        },
+      ],
+    });
+  }
+
+  const output = await extras.ide.runCommandWithOutput(command, cwd);
+
+  if (output) {
+    return [
+      {
+        name: "Terminal",
+        description: "Terminal command output",
+        content: output,
+        status: "Command completed",
+      },
+    ];
+  }
+
+  // Shell integration unavailable — fall back to sendText with no capture
   await extras.ide.runCommand(command);
   return [
     {
       name: "Terminal",
       description: "Terminal command output",
       content:
-        "Terminal output not available. This is only available in local development environments and not in SSH environments for example.",
-      status: "Command failed",
+        "Command was sent to the terminal but output capture is not available. " +
+        "This requires VS Code 1.93+ with shell integration enabled. " +
+        "Check the terminal panel for output.",
+      status: "Command sent (no output capture)",
     },
   ];
 };

core/tools/implementations/runTerminalCommand.vitest.ts

@@ -95,6 +95,7 @@ describe("runTerminalCommandImpl", () => {
       getIdeInfo: mockGetIdeInfo,
       getWorkspaceDirs: mockGetWorkspaceDirs,
       runCommand: mockRunCommand,
+      runCommandWithOutput: vi.fn().mockResolvedValue(""),
       // Add stubs for other required IDE methods
       getIdeSettings: vi.fn(),
       getDiff: vi.fn(),
@@ -269,13 +270,13 @@ describe("runTerminalCommandImpl", () => {
 
     const result = await runTerminalCommandImpl(args, extras);
 
-    // In remote environments, it should use the IDE's runCommand
+    // In remote environments, it should try runCommandWithOutput first,
+    // then fall back to ide.runCommand when output is empty
     expect(mockRunCommand).toHaveBeenCalledWith("echo 'test'");
     // Match the actual output message
-    expect(result[0].content).toContain("Terminal output not available");
-    expect(result[0].content).toContain("SSH environments");
-    // Verify status field indicates command failed in remote environments
-    expect(result[0].status).toBe("Command failed");
+    expect(result[0].content).toContain("output capture is not available");
+    // Verify status field indicates command was sent without capture
+    expect(result[0].status).toBe("Command sent (no output capture)");
   });
 
   it("should handle errors when executing invalid commands", async () => {
@@ -370,6 +371,7 @@ describe("runTerminalCommandImpl", () => {
         .mockReturnValue(Promise.resolve({ remoteName: "local" })),
       getWorkspaceDirs: mockEmptyWorkspace,
       runCommand: vi.fn(),
+      runCommandWithOutput: vi.fn().mockResolvedValue(""),
       getIdeSettings: vi.fn(),
       getDiff: vi.fn(),
       getClipboardContent: vi.fn(),
@@ -430,6 +432,7 @@ describe("runTerminalCommandImpl", () => {
           .mockReturnValue(Promise.resolve({ remoteName: "local" })),
         getWorkspaceDirs: mockEmptyWorkspace,
         runCommand: vi.fn(),
+        runCommandWithOutput: vi.fn().mockResolvedValue(""),
         getIdeSettings: vi.fn(),
         getDiff: vi.fn(),
         getClipboardContent: vi.fn(),
@@ -619,7 +622,7 @@ describe("runTerminalCommandImpl", () => {
         );
 
         expect(mockRunCommand).toHaveBeenCalledWith("echo test");
-        expect(result[0].content).toContain("Terminal output not available");
+        expect(result[0].content).toContain("output capture is not available");
       });
 
       it("should handle local environment with file URIs", async () => {
@@ -660,7 +663,7 @@ describe("runTerminalCommandImpl", () => {
 
           // Should fall back to ide.runCommand, not try to spawn powershell.exe
           expect(mockRunCommand).toHaveBeenCalledWith("echo test");
-          expect(result[0].content).toContain("Terminal output not available");
+          expect(result[0].content).toContain("output capture is not available");
         } finally {
           Object.defineProperty(process, "platform", {
             value: originalPlatform,

core/util/filesystem.ts

@@ -232,6 +232,10 @@ class FileSystemIde implements IDE {
     return Promise.resolve();
   }
 
+  runCommandWithOutput(command: string, cwd?: string): Promise<string> {
+    return Promise.resolve("");
+  }
+
   saveFile(fileUri: string): Promise<void> {
     return Promise.resolve();
   }

extensions/vscode/src/VsCodeIde.ts

@@ -355,6 +355,89 @@ class VsCodeIde implements IDE {
     terminal.sendText(command, false);
   }
 
+  async runCommandWithOutput(
+    command: string,
+    cwd?: string,
+  ): Promise<string> {
+    const terminal = vscode.window.createTerminal({
+      name: "Continue",
+      cwd: cwd ? vscode.Uri.parse(cwd) : undefined,
+    });
+
+    const shellIntegration = await this.waitForShellIntegration(terminal, 10000);
+
+    if (!shellIntegration) {
+      terminal.show();
+      terminal.sendText(command, true);
+      return "";
+    }
+
+    try {
+      const execution = shellIntegration.executeCommand(command);
+      let output = "";
+
+      for await (const chunk of execution.read()) {
+        output += chunk;
+      }
+
+      const exitCode = await execution.exitCode;
+      if (exitCode !== undefined && exitCode !== 0) {
+        output += `\n[Exit code: ${exitCode}]`;
+      }
+
+      // Strip VS Code shell integration OSC sequences (]633;...) but preserve
+      // ANSI color/formatting codes (e.g. \033[31m) which are part of command output
+      output = output.replace(/\x1b\]633;[^\x07]*\x07/g, "");
+      // Also strip OSC sequences that lost their escape byte during read()
+      output = output.replace(/\]633;[^\n]*/g, "");
+      output = output.trim();
+
+      terminal.dispose();
+      return output;
+    } catch (error) {
+      console.error("[Continue] shellIntegration.executeCommand failed:", error);
+      terminal.dispose();
+      return "";
+    }
+  }
+
+  private async waitForShellIntegration(
+    terminal: vscode.Terminal,
+    timeoutMs: number,
+  ): Promise<any> {
+    if ((terminal as any).shellIntegration) {
+      return (terminal as any).shellIntegration;
+    }
+
+    if (!(vscode.window as any).onDidChangeTerminalShellIntegration) {
+      return undefined;
+    }
+
+    return new Promise<any>((resolve) => {
+      const timeout = setTimeout(() => {
+        disposable.dispose();
+        resolve(undefined);
+      }, timeoutMs);
+
+      const disposable = (
+        vscode.window as any
+      ).onDidChangeTerminalShellIntegration((e: any) => {
+        if (e.terminal === terminal) {
+          clearTimeout(timeout);
+          disposable.dispose();
+          resolve(e.shellIntegration);
+        }
+      });
+
+      // Race condition guard
+      if ((terminal as any).shellIntegration) {
+        clearTimeout(timeout);
+        disposable.dispose();
+        resolve((terminal as any).shellIntegration);
+      }
+    });
+  }
+
   async saveFile(fileUri: string): Promise<void> {
     await this.ideUtils.saveFile(vscode.Uri.parse(fileUri));
   }

extensions/vscode/src/extension/VsCodeMessenger.ts

@@ -722,6 +722,9 @@ export class VsCodeMessenger {
     this.onWebviewOrCore("runCommand", async (msg) => {
       await ide.runCommand(msg.data.command);
     });
+    this.onWebviewOrCore("runCommandWithOutput", async (msg) => {
+      return ide.runCommandWithOutput(msg.data.command, msg.data.cwd);
+    });
     this.onWebviewOrCore("getSearchResults", async (msg) => {
       return ide.getSearchResults(msg.data.query, msg.data.maxResults);
     });