@aion0/forge 0.5.43 → 0.5.44

package/vscode-extension/src/docs/fs-provider.ts

@@ -0,0 +1,94 @@
+import * as vscode from 'vscode';
+import { ForgeClient } from '../api/client';
+
+/**
+ * `forge-docs://` URIs map to forge's HTTP API for read/write — used in
+ * remote-forge mode where the doc files live on a different machine.
+ *
+ *   GET  /api/docs?root=<N>&file=<path>  (text)
+ *   GET  /api/docs?root=<N>&image=<path> (binary)
+ *   PUT  /api/docs                       (write)
+ *
+ * VSCode treats files opened via this scheme as real files: the editor tab
+ * shows the actual filename, Cmd+S saves through writeFile, all editor
+ * features work.
+ */
+export class ForgeDocsFs implements vscode.FileSystemProvider {
+  private _emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
+  onDidChangeFile = this._emitter.event;
+
+  constructor(private client: ForgeClient) {}
+
+  watch(): vscode.Disposable {
+    return new vscode.Disposable(() => {});
+  }
+
+  async stat(uri: vscode.Uri): Promise<vscode.FileStat> {
+    const { path } = parseDocUri(uri);
+    if (!path) return { type: vscode.FileType.Directory, ctime: 0, mtime: 0, size: 0 };
+    return { type: vscode.FileType.File, ctime: 0, mtime: Date.now(), size: 0 };
+  }
+
+  async readDirectory(): Promise<[string, vscode.FileType][]> { return []; }
+  createDirectory(): void { throw vscode.FileSystemError.NoPermissions(); }
+
+  async readFile(uri: vscode.Uri): Promise<Uint8Array> {
+    const { rootIdx, path } = parseDocUri(uri);
+    if (isImagePath(path)) {
+      const bytes = await fetchImageBytes(this.client, rootIdx, path);
+      if (!bytes) throw vscode.FileSystemError.FileNotFound(uri);
+      return bytes;
+    }
+    const r = await this.client.request<any>(`/api/docs?root=${rootIdx}&file=${encodeURIComponent(path)}`);
+    if (!r.ok) throw vscode.FileSystemError.FileNotFound(uri);
+    if (r.data?.tooLarge) throw vscode.FileSystemError.NoPermissions('File too large');
+    if (r.data?.binary) throw vscode.FileSystemError.NoPermissions(`Binary ${r.data.fileType} file`);
+    return Buffer.from(r.data?.content || '', 'utf-8');
+  }
+
+  async writeFile(uri: vscode.Uri, content: Uint8Array): Promise<void> {
+    const { rootIdx, path } = parseDocUri(uri);
+    const text = Buffer.from(content).toString('utf-8');
+    const r = await this.client.request('/api/docs', {
+      method: 'PUT',
+      body: JSON.stringify({ root: rootIdx, file: path, content: text }),
+    });
+    if (!r.ok) {
+      vscode.window.showErrorMessage(`Forge: failed to save ${path} — ${r.error}`);
+      throw vscode.FileSystemError.NoPermissions(`Save failed: ${r.error}`);
+    }
+    this._emitter.fire([{ type: vscode.FileChangeType.Changed, uri }]);
+  }
+
+  delete(): void { throw vscode.FileSystemError.NoPermissions(); }
+  rename(): void { throw vscode.FileSystemError.NoPermissions(); }
+}
+
+export function buildDocUri(rootIdx: number, path: string): vscode.Uri {
+  return vscode.Uri.parse(`forge-docs:/${rootIdx}/${path.split('/').map(encodeURIComponent).join('/')}`);
+}
+
+function parseDocUri(uri: vscode.Uri): { rootIdx: number; path: string } {
+  const segments = uri.path.split('/').filter(Boolean);
+  const rootIdx = parseInt(segments[0] || '0', 10) || 0;
+  const path = segments.slice(1).map(decodeURIComponent).join('/');
+  return { rootIdx, path };
+}
+
+function isImagePath(path: string): boolean {
+  const ext = path.toLowerCase().split('.').pop() || '';
+  return ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'bmp', 'ico', 'avif'].includes(ext);
+}
+
+async function fetchImageBytes(client: ForgeClient, rootIdx: number, path: string): Promise<Uint8Array | null> {
+  const token = await client.getToken();
+  const headers: Record<string, string> = {};
+  if (token) headers['X-Forge-Token'] = token;
+  try {
+    const res = await fetch(`${client.baseUrlPublic}/api/docs?root=${rootIdx}&image=${encodeURIComponent(path)}`, { headers });
+    if (!res.ok) return null;
+    return new Uint8Array(await res.arrayBuffer());
+  } catch {
+    return null;
+  }
+}

package/vscode-extension/src/docs/result-provider.ts

@@ -0,0 +1,33 @@
+import * as vscode from 'vscode';
+
+/** Read-only TextDocumentContentProvider for `forge-result://` URIs.
+ *
+ *  Used for ephemeral detail views (pipeline node result, error dumps, etc).
+ *  Each click on the same logical thing reuses the same URI → preview-mode
+ *  tabs replace each other, no untitled buffer, no save prompt on close.
+ *
+ *  URI shape: `forge-result:/<key>.md` — `<key>` should encode whatever makes
+ *  the document unique (run id + node name, etc). The `.md` suffix lets
+ *  VSCode auto-pick the markdown language.
+ */
+export class ForgeResultProvider implements vscode.TextDocumentContentProvider {
+  private _onDidChange = new vscode.EventEmitter<vscode.Uri>();
+  onDidChange = this._onDidChange.event;
+  private contents = new Map<string, string>();
+
+  setContent(uri: vscode.Uri, content: string): void {
+    this.contents.set(uri.toString(), content);
+    this._onDidChange.fire(uri);
+  }
+
+  provideTextDocumentContent(uri: vscode.Uri): string {
+    return this.contents.get(uri.toString()) || '';
+  }
+}
+
+export const SCHEME = 'forge-result';
+
+export function buildResultUri(key: string): vscode.Uri {
+  // Encode key, ensure .md suffix for markdown highlighting.
+  return vscode.Uri.parse(`${SCHEME}:/${encodeURIComponent(key)}.md`);
+}

package/vscode-extension/src/docs/transport.ts

@@ -0,0 +1,22 @@
+import * as vscode from 'vscode';
+
+export type DocsTransport = 'local' | 'http';
+
+/** Detect whether forge is reachable as the local filesystem (we can use
+ *  `vscode.Uri.file(absPath)`) or only over the wire (we must go through
+ *  the forge-docs:// FileSystemProvider). */
+export function detectDocsTransport(): DocsTransport {
+  const cfg = vscode.workspace.getConfiguration('forge');
+  const setting = cfg.get<string>('docs.transport', 'auto');
+  if (setting === 'local') return 'local';
+  if (setting === 'http') return 'http';
+  // Auto: localhost / 127.0.0.1 / [::1] → local, else http
+  const serverUrl = cfg.get<string>('serverUrl', 'http://localhost:8403');
+  try {
+    const u = new URL(serverUrl);
+    const local = ['localhost', '127.0.0.1', '[::1]', '::1'].includes(u.hostname);
+    return local ? 'local' : 'http';
+  } catch {
+    return 'http';
+  }
+}

package/vscode-extension/src/extension.ts

@@ -0,0 +1,314 @@
+import * as vscode from 'vscode';
+import { Auth } from './auth/auth';
+import { ConnectionManager } from './connection/manager';
+import { ForgeClient } from './api/client';
+import { switchConnectionCommand, addConnectionCommand, removeConnectionCommand, editConnectionsCommand } from './commands/connection';
+import { WorkspacesProvider } from './views/workspaces';
+import { TerminalsProvider } from './views/terminals';
+import { PipelinesProvider } from './views/pipelines';
+import { DocsProvider } from './views/docs';
+import { StatusBar } from './statusbar';
+import { loginCommand, logoutCommand } from './commands/auth';
+import { openTerminalCommand, attachTerminalCommand, openSessionCommand, sendSelectionCommand } from './commands/terminal';
+import { startServerCommand, stopServerCommand, openWebUICommand } from './commands/server';
+import { newTaskCommand } from './commands/task';
+import {
+  openWorkspaceForFolderCommand, openWorkspaceCommand,
+  startDaemonCommand, stopDaemonCommand, restartDaemonCommand,
+} from './commands/workspace';
+import {
+  smithOpenTerminalCommand, smithPauseCommand, smithResumeCommand,
+  smithMarkDoneCommand, smithMarkFailedCommand, smithMarkIdleCommand,
+  smithRetryCommand, smithSendMessageCommand, registerSmithTerminalCleanup,
+} from './commands/smith';
+import { openDocCommand, openDocsTerminalCommand } from './commands/docs';
+import { ForgeDocsFs } from './docs/fs-provider';
+import { ForgeResultProvider, SCHEME as RESULT_SCHEME, buildResultUri } from './docs/result-provider';
+import { addPipelineCommand, triggerPipelineCommand, togglePipelineCommand, removePipelineCommand } from './commands/pipeline';
+
+export async function activate(context: vscode.ExtensionContext): Promise<void> {
+  const auth = new Auth(context.secrets);
+  const conn = new ConnectionManager();
+  conn.watchConfig(context);
+  const client = new ForgeClient(auth, conn);
+
+  // One-time migration of legacy single-token storage to per-connection.
+  await auth.migrateLegacy(conn.active().name);
+
+  // Smith terminal cache — reuse VSCode terminal pane on repeated click
+  registerSmithTerminalCleanup(context);
+
+  // Tree views
+  const wsProvider       = new WorkspacesProvider(client);
+  const termProvider     = new TerminalsProvider(client);
+  const pipelineProvider = new PipelinesProvider(client);
+  const docsProvider     = new DocsProvider(client);
+  context.subscriptions.push(
+    vscode.window.registerTreeDataProvider('forge.workspaces', wsProvider),
+    vscode.window.registerTreeDataProvider('forge.terminals',  termProvider),
+    vscode.window.registerTreeDataProvider('forge.pipelines',  pipelineProvider),
+    vscode.window.registerTreeDataProvider('forge.docs',       docsProvider),
+  );
+
+  const refreshAll = () => {
+    wsProvider.refresh();
+    termProvider.refresh();
+    pipelineProvider.refresh();
+    docsProvider.refresh();
+  };
+
+  // Status bar
+  const status = new StatusBar(client, auth);
+  context.subscriptions.push(status);
+  const interval = vscode.workspace.getConfiguration('forge').get<number>('refreshInterval', 5);
+  status.startPolling(interval);
+
+  // Auto-refresh tree views on the same interval
+  const treeTimer = setInterval(refreshAll, Math.max(interval, 2) * 1000);
+  context.subscriptions.push({ dispose: () => clearInterval(treeTimer) });
+
+  // Commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('forge.login',         () => loginCommand(client)),
+    vscode.commands.registerCommand('forge.logout',        () => logoutCommand(client)),
+    vscode.commands.registerCommand('forge.startServer',   () => startServerCommand(client)),
+    vscode.commands.registerCommand('forge.stopServer',    () => stopServerCommand()),
+    vscode.commands.registerCommand('forge.openWebUI',     () => openWebUICommand(client)),
+    vscode.commands.registerCommand('forge.openTerminal',  () => openTerminalCommand(client)),
+    vscode.commands.registerCommand('forge.attachTerminal',(arg) => attachTerminalCommand(client, arg)),
+    vscode.commands.registerCommand('forge.openSession',   (arg) => openSessionCommand(client, arg)),
+    vscode.commands.registerCommand('forge.sendSelection', () => sendSelectionCommand(client)),
+    vscode.commands.registerCommand('forge.newTask',       () => newTaskCommand(client)),
+    vscode.commands.registerCommand('forge.refresh',       () => { refreshAll(); status.update(); }),
+
+    // Connection management
+    vscode.commands.registerCommand('forge.switchConnection', () => switchConnectionCommand(conn)),
+    vscode.commands.registerCommand('forge.addConnection',    () => addConnectionCommand(conn)),
+    vscode.commands.registerCommand('forge.removeConnection', () => removeConnectionCommand(conn)),
+    vscode.commands.registerCommand('forge.editConnections',  () => editConnectionsCommand()),
+
+    // Workspace bootstrap + daemon control
+    vscode.commands.registerCommand('forge.openWorkspaceForFolder', () => openWorkspaceForFolderCommand(client)),
+    vscode.commands.registerCommand('forge.openWorkspace',          () => openWorkspaceCommand(client)),
+    vscode.commands.registerCommand('forge.startDaemon',  (arg) => startDaemonCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.stopDaemon',   (arg) => stopDaemonCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.restartDaemon',(arg) => restartDaemonCommand(client, arg?.meta || arg)),
+
+    // Smith actions (right-click menu + click)
+    vscode.commands.registerCommand('forge.smithOpenTerminal', (arg) => smithOpenTerminalCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithPause',        (arg) => smithPauseCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithResume',       (arg) => smithResumeCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithMarkDone',     (arg) => smithMarkDoneCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithMarkFailed',   (arg) => smithMarkFailedCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithMarkIdle',     (arg) => smithMarkIdleCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithRetry',        (arg) => smithRetryCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.smithSendMessage',  (arg) => smithSendMessageCommand(client, arg?.meta || arg)),
+
+    // Docs
+    vscode.commands.registerCommand('forge.openDoc',           (arg) => openDocCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.openDocsTerminal',  (arg) => openDocsTerminalCommand(client, arg?.meta || arg)),
+
+    // Pipelines (project-bound)
+    vscode.commands.registerCommand('forge.addPipeline',       (arg) => addPipelineCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.triggerPipeline',   (arg) => triggerPipelineCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.togglePipeline',    (arg) => togglePipelineCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.removePipeline',    (arg) => removePipelineCommand(client, arg?.meta || arg)),
+    vscode.commands.registerCommand('forge.showPipelineNodeError', async (arg) => {
+      if (!arg?.error) return;
+      const uri = buildResultUri(`error/${arg.nodeName}`);
+      resultProvider.setContent(uri, `# Pipeline node \`${arg.nodeName}\` failed\n\n\`\`\`\n${arg.error}\n\`\`\`\n`);
+      await vscode.commands.executeCommand('vscode.open', uri);
+    }),
+
+    // Pipeline node detail view. Combines whatever we know — node status,
+    // duration, error, outputs — plus the underlying forge task (if its ID is
+    // resolvable). A pipeline node's taskId may not always map to /api/tasks
+    // (different ID spaces depending on workflow type), so a 404 is silently
+    // skipped rather than rendered as an error.
+    vscode.commands.registerCommand('forge.showPipelineNodeResult', async (arg) => {
+      if (!arg) return;
+      const lines: string[] = [];
+      lines.push(`# Pipeline node: \`${arg.nodeName}\``);
+      lines.push('');
+      lines.push(`**Status:** ${arg.status || 'unknown'}`);
+      if (arg.taskId) lines.push(`**Task ID:** \`${arg.taskId}\``);
+      if (arg.startedAt) {
+        const start = new Date(arg.startedAt).toLocaleString();
+        const end = arg.completedAt ? new Date(arg.completedAt).toLocaleString() : '(running)';
+        const dur = arg.completedAt
+          ? `${Math.round((new Date(arg.completedAt).getTime() - new Date(arg.startedAt).getTime()) / 1000)}s`
+          : '';
+        lines.push(`**Started:** ${start}`);
+        lines.push(`**Completed:** ${end}${dur ? `  (${dur})` : ''}`);
+      }
+      lines.push('');
+
+      // Pull the underlying task if we can — silently skip on 404.
+      let task: any = null;
+      if (arg.taskId) {
+        const r = await client.getTask(arg.taskId);
+        if (r.ok && r.data) task = r.data;
+      }
+
+      if (task) {
+        if (task.prompt) {
+          lines.push('## Prompt');
+          lines.push('```');
+          lines.push(task.prompt);
+          lines.push('```');
+          lines.push('');
+        }
+        if (task.resultSummary) {
+          lines.push('## Result');
+          lines.push(task.resultSummary);
+          lines.push('');
+        }
+        if (task.gitDiff) {
+          lines.push('## Git Diff');
+          lines.push('```diff');
+          lines.push(task.gitDiff);
+          lines.push('```');
+          lines.push('');
+        }
+        if (Array.isArray(task.log) && task.log.length > 0) {
+          lines.push('## Log (last 20 entries)');
+          for (const e of task.log.slice(-20)) {
+            const time = e.timestamp ? new Date(e.timestamp).toLocaleTimeString() : '';
+            const tag = e.subtype || e.type || 'log';
+            const content = (e.content || '').toString();
+            lines.push(`- \`[${time}] [${tag}]\` ${content.slice(0, 500).replace(/\n/g, ' ')}`);
+          }
+          lines.push('');
+        }
+        if (task.costUSD) {
+          lines.push(`**Cost:** $${task.costUSD.toFixed?.(4) ?? task.costUSD}`);
+          lines.push('');
+        }
+      }
+
+      if (arg.error) {
+        lines.push('## Error');
+        lines.push('```');
+        lines.push(String(arg.error));
+        lines.push('```');
+        lines.push('');
+      }
+
+      if (arg.outputs && Object.keys(arg.outputs).length > 0) {
+        lines.push('## Outputs');
+        for (const [k, v] of Object.entries(arg.outputs)) {
+          lines.push(`### ${k}`);
+          lines.push('```');
+          lines.push(typeof v === 'string' ? v : JSON.stringify(v, null, 2));
+          lines.push('```');
+          lines.push('');
+        }
+      }
+
+      // If we got nothing useful at all (pending node, or node didn't track a
+      // task), say so explicitly instead of leaving a near-empty doc.
+      if (!task && !arg.error && !(arg.outputs && Object.keys(arg.outputs).length > 0)) {
+        lines.push('---');
+        lines.push('');
+        if (arg.status === 'pending') {
+          lines.push('_Node has not run yet — re-open after the pipeline reaches it._');
+        } else if (arg.taskId) {
+          lines.push(`_The associated task \`${arg.taskId}\` is no longer in the forge task store. The node may have run via the workspace daemon (which uses a separate ID space) or the task was cleaned up._`);
+        } else {
+          lines.push('_This node did not produce any task output, error, or named outputs._');
+        }
+      }
+
+      // Use a stable URI per (run, node) so re-clicking the same node reuses
+      // the tab; clicking a different node opens in preview mode and replaces
+      // the previous unpinned preview tab.
+      const key = `node/${arg.runId || 'std'}/${arg.nodeName}`;
+      const uri = buildResultUri(key);
+      resultProvider.setContent(uri, lines.join('\n'));
+      await vscode.commands.executeCommand('vscode.open', uri);
+    }),
+
+    // Quick-open in forge web UI. Forge supports `?view=<mode>` to deep-link
+    // into a section — the calling tree item passes a `view` hint via meta.
+    vscode.commands.registerCommand('forge.openItemInWebUI', (arg) => {
+      const meta = arg?.meta || arg || {};
+      const view = meta.view || meta.webUiView;
+      const base = client.baseUrlPublic;
+      const url = view ? `${base}/?view=${encodeURIComponent(view)}` : base;
+      vscode.env.openExternal(vscode.Uri.parse(url));
+    }),
+  );
+
+  // Always register the forge-docs:// FS provider — used when transport is
+  // 'http' (auto-selected for remote forges, or forced via settings).
+  context.subscriptions.push(
+    vscode.workspace.registerFileSystemProvider('forge-docs', new ForgeDocsFs(client), { isCaseSensitive: true }),
+  );
+
+  // Read-only virtual provider for ephemeral detail views (pipeline node
+  // results, error dumps). Same URI = same tab, no save prompt on close.
+  const resultProvider = new ForgeResultProvider();
+  context.subscriptions.push(
+    vscode.workspace.registerTextDocumentContentProvider(RESULT_SCHEME, resultProvider),
+  );
+
+  // Auto-start option
+  if (vscode.workspace.getConfiguration('forge').get<boolean>('autoStart', false)) {
+    if (!(await client.ping())) {
+      void startServerCommand(client);
+    }
+  }
+
+  // First-run UX: if forge is reachable but we have no token, prompt for login
+  // immediately. Otherwise users have to dig through the command palette.
+  void (async () => {
+    // Wait briefly so a freshly auto-started server has a chance to come up.
+    await new Promise(r => setTimeout(r, 800));
+    if (!(await client.ping())) return;          // server offline → status bar already says so
+    if (await auth.getToken(client.activeName)) {
+      // Token exists, but verify it still works (server may have been restarted)
+      const probe = await client.listProjects();
+      if (probe.status === 401 || probe.status === 403) {
+        await client.logout();
+      } else {
+        return;
+      }
+    }
+    // No token (or stale token cleared) → ask now
+    void loginCommand(client);
+  })();
+
+  // Notifications: poll unread bell events
+  if (vscode.workspace.getConfiguration('forge').get<boolean>('notifications.enabled', true)) {
+    const seen = new Set<string>();
+    const notifyTimer = setInterval(async () => {
+      const r = await client.getNotifications();
+      const list: any[] = r.ok && r.data?.notifications ? r.data.notifications : [];
+      for (const n of list) {
+        if (n.read || seen.has(n.id)) continue;
+        seen.add(n.id);
+        vscode.window.showInformationMessage(`Forge: ${n.title || n.message || 'notification'}`);
+      }
+    }, 30_000);
+    context.subscriptions.push({ dispose: () => clearInterval(notifyTimer) });
+  }
+
+  // Re-read settings when the user changes them
+  context.subscriptions.push(vscode.workspace.onDidChangeConfiguration(e => {
+    if (e.affectsConfiguration('forge.refreshInterval')) {
+      const i = vscode.workspace.getConfiguration('forge').get<number>('refreshInterval', 5);
+      status.startPolling(i);
+    }
+  }));
+
+  // When the active connection switches (or its URLs change), reset everything
+  // that depends on it: trees, status, and any cached state.
+  context.subscriptions.push(conn.onDidChange(() => {
+    refreshAll();
+    void status.update();
+  }));
+}
+
+export function deactivate(): void {
+  // disposables are released by VSCode automatically
+}

package/vscode-extension/src/statusbar.ts

@@ -0,0 +1,70 @@
+import * as vscode from 'vscode';
+import { ForgeClient } from './api/client';
+import { Auth } from './auth/auth';
+
+type Status = 'connected' | 'auth' | 'offline';
+
+export class StatusBar {
+  private item: vscode.StatusBarItem;
+  private timer: NodeJS.Timeout | null = null;
+
+  constructor(private client: ForgeClient, private auth: Auth) {
+    this.item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 100);
+    this.item.command = 'forge.openWebUI';
+    this.item.show();
+  }
+
+  async update(): Promise<void> {
+    const state = await this.detect();
+    const connName = this.client.activeName;
+    switch (state) {
+      case 'connected':
+        this.item.text = `$(zap) Forge: ${connName}`;
+        this.item.tooltip = `Forge connected (${connName}) — click to switch connection`;
+        this.item.command = 'forge.switchConnection';
+        this.item.backgroundColor = undefined;
+        break;
+      case 'auth':
+        this.item.text = `$(key) Forge: ${connName}`;
+        this.item.tooltip = `Forge (${connName}): login required`;
+        this.item.command = 'forge.login';
+        this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+        break;
+      case 'offline':
+        this.item.text = `$(circle-slash) Forge: ${connName}`;
+        this.item.tooltip = `Forge (${connName}) unreachable — click to switch connection`;
+        this.item.command = 'forge.switchConnection';
+        this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground');
+        break;
+    }
+  }
+
+  private async detect(): Promise<Status> {
+    const reachable = await this.client.ping();
+    if (!reachable) return 'offline';
+    const token = await this.auth.getToken(this.client.activeName);
+    if (!token) return 'auth';
+    // Quick auth probe: fetch any authed endpoint
+    const r = await this.client.listProjects();
+    if (r.status === 401 || r.status === 403) return 'auth';
+    return 'connected';
+  }
+
+  startPolling(seconds: number): void {
+    this.stopPolling();
+    void this.update();
+    this.timer = setInterval(() => void this.update(), seconds * 1000);
+  }
+
+  stopPolling(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  dispose(): void {
+    this.stopPolling();
+    this.item.dispose();
+  }
+}

package/vscode-extension/src/terminal/pseudoterm.ts

@@ -0,0 +1,123 @@
+import * as vscode from 'vscode';
+import WebSocket from 'ws';
+
+export interface ForgePtyOptions {
+  url: string;             // ws://host:port
+  attach?: string;         // existing tmux session name to attach to
+  cwd?: string;            // for newly created sessions
+  /** Command auto-typed after the new tmux session is connected (e.g. `claude --resume <id>`).
+   *  Ignored on attach. */
+  launchCommand?: string;
+  cols?: number;
+  rows?: number;
+}
+
+/**
+ * VSCode Pseudoterminal that bridges to Forge's terminal WebSocket.
+ *
+ * Protocol (from lib/terminal-standalone.ts):
+ *   client → server: { type: 'attach' | 'create', sessionName?, cols, rows, cwd? }
+ *                    { type: 'input', data }
+ *                    { type: 'resize', cols, rows }
+ *   server → client: { type: 'output', data }
+ *                    { type: 'connected', sessionName }
+ *                    { type: 'error', message }
+ */
+export class ForgePty implements vscode.Pseudoterminal {
+  private writeEmitter = new vscode.EventEmitter<string>();
+  private closeEmitter = new vscode.EventEmitter<number>();
+  private ws: WebSocket | null = null;
+  private cols = 80;
+  private rows = 24;
+  private opened = false;
+
+  onDidWrite = this.writeEmitter.event;
+  onDidClose = this.closeEmitter.event;
+
+  constructor(private opts: ForgePtyOptions) {
+    this.cols = opts.cols || 80;
+    this.rows = opts.rows || 24;
+  }
+
+  open(initialDimensions: vscode.TerminalDimensions | undefined): void {
+    if (initialDimensions) {
+      this.cols = initialDimensions.columns;
+      this.rows = initialDimensions.rows;
+    }
+    this.opened = true;
+    this.connect();
+  }
+
+  close(): void {
+    this.opened = false;
+    if (this.ws) {
+      try { this.ws.close(); } catch {}
+      this.ws = null;
+    }
+  }
+
+  handleInput(data: string): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: 'input', data }));
+    }
+  }
+
+  setDimensions(dims: vscode.TerminalDimensions): void {
+    this.cols = dims.columns;
+    this.rows = dims.rows;
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: 'resize', cols: this.cols, rows: this.rows }));
+    }
+  }
+
+  private connect(): void {
+    const ws = new WebSocket(this.opts.url);
+    this.ws = ws;
+
+    ws.on('open', () => {
+      const msg = this.opts.attach
+        ? { type: 'attach', sessionName: this.opts.attach, cols: this.cols, rows: this.rows }
+        : { type: 'create', cols: this.cols, rows: this.rows, cwd: this.opts.cwd };
+      ws.send(JSON.stringify(msg));
+      this.writeEmitter.fire(this.opts.attach
+        ? `\x1b[2m[forge] attaching to ${this.opts.attach}…\x1b[0m\r\n`
+        : `\x1b[2m[forge] creating new session…\x1b[0m\r\n`);
+    });
+
+    ws.on('message', (raw) => {
+      try {
+        const m = JSON.parse(raw.toString());
+        if (m.type === 'output' && typeof m.data === 'string') {
+          this.writeEmitter.fire(m.data);
+        } else if (m.type === 'error') {
+          this.writeEmitter.fire(`\r\n\x1b[31m[forge] ${m.message || 'error'}\x1b[0m\r\n`);
+        } else if (m.type === 'connected') {
+          // For freshly created sessions, auto-type the launch command (claude --resume ...).
+          if (this.opts.launchCommand && !this.opts.attach) {
+            // Small delay so the bash prompt is fully ready before we type.
+            setTimeout(() => {
+              if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'input', data: this.opts.launchCommand + '\n' }));
+              }
+            }, 200);
+          }
+        } else if (m.type === 'sessions') {
+          // ignore — list response we didn't ask for
+        }
+      } catch {
+        // ignore non-JSON
+      }
+    });
+
+    ws.on('close', () => {
+      if (this.opened) {
+        this.writeEmitter.fire('\r\n\x1b[2m[forge] terminal closed\x1b[0m\r\n');
+        this.closeEmitter.fire(0);
+      }
+    });
+
+    ws.on('error', (err: Error) => {
+      this.writeEmitter.fire(`\r\n\x1b[31m[forge] WS error: ${err.message}\x1b[0m\r\n`);
+    });
+  }
+}