@aion0/forge 0.5.43 → 0.5.44

package/vscode-extension/src/api/client.ts

@@ -0,0 +1,217 @@
+import { Auth } from '../auth/auth';
+import { ConnectionManager } from '../connection/manager';
+
+export interface ApiResponse<T = any> {
+  ok: boolean;
+  data?: T;
+  status: number;
+  error?: string;
+}
+
+export class ForgeClient {
+  constructor(private auth: Auth, private conn: ConnectionManager) {}
+
+  private get baseUrl(): string { return this.conn.active().serverUrl; }
+  get terminalUrl(): string     { return this.conn.active().terminalUrl; }
+  /** Public read of the active connection's HTTP base URL. */
+  get baseUrlPublic(): string   { return this.baseUrl; }
+  /** Active connection's display name — used as the SecretStorage token key. */
+  get activeName(): string      { return this.conn.active().name; }
+
+  /** Verify password and store the resulting token under the active connection. */
+  async login(password: string): Promise<{ ok: boolean; error?: string }> {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/auth/verify`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ password }),
+      });
+      const data = await res.json() as { ok?: boolean; token?: string; error?: string };
+      if (!res.ok || !data.ok || !data.token) {
+        return { ok: false, error: data.error || `HTTP ${res.status}` };
+      }
+      await this.auth.setToken(this.activeName, data.token);
+      return { ok: true };
+    } catch (e: any) {
+      return { ok: false, error: e?.message || 'Network error' };
+    }
+  }
+
+  async logout(): Promise<void> {
+    await this.auth.clearToken(this.activeName);
+  }
+
+  /** Token for the active connection (used by raw fetch helpers). */
+  async getToken(): Promise<string | undefined> {
+    return this.auth.getToken(this.activeName);
+  }
+
+  /** True if forge is reachable on the current serverUrl, regardless of auth. */
+  async ping(): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/version`, { signal: AbortSignal.timeout(2000) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async request<T = any>(path: string, init: RequestInit = {}): Promise<ApiResponse<T>> {
+    const token = await this.auth.getToken(this.activeName);
+    const headers = new Headers(init.headers);
+    headers.set('Content-Type', 'application/json');
+    if (token) headers.set('X-Forge-Token', token);
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, { ...init, headers });
+      const text = await res.text();
+      let data: any;
+      try { data = text ? JSON.parse(text) : undefined; } catch { data = text; }
+      if (!res.ok) {
+        return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+      }
+      return { ok: true, status: res.status, data };
+    } catch (e: any) {
+      return { ok: false, status: 0, error: e?.message || 'Network error' };
+    }
+  }
+
+  // ── High-level helpers ──────────────────────────────
+
+  listProjects()    { return this.request<any[]>('/api/projects'); }
+  listWorkspaces()  { return this.request<any[]>('/api/workspace'); }
+  /** Returns { agents, states, busLog, daemonActive } */
+  getWorkspaceAgents(id: string) {
+    return this.request<{ agents: any[]; states: Record<string, any>; busLog?: any[]; daemonActive?: boolean }>(`/api/workspace/${id}/agents`);
+  }
+  listTasks()       { return this.request<any[]>('/api/tasks'); }
+  listTerminals()   { return this.request<any>('/api/terminal-state'); }
+  getNotifications(){ return this.request<any>('/api/notifications'); }
+  /** Returns { fixedSessionId } for a given project path, or null if not bound. */
+  getProjectSession(projectPath: string) {
+    return this.request<{ fixedSessionId: string | null }>(`/api/project-sessions?projectPath=${encodeURIComponent(projectPath)}`);
+  }
+
+  /** Returns recent claude sessions for a project, newest first. */
+  listClaudeSessions(projectName: string) {
+    return this.request<any[]>(`/api/claude-sessions/${encodeURIComponent(projectName)}`);
+  }
+
+  /** List all configured agents + the default. */
+  listAgents() {
+    return this.request<{ agents: any[]; defaultAgent: string }>('/api/agents');
+  }
+
+  /** Resolve launch info for an agent: { cliCmd, cliType, supportsSession, env?, model? } */
+  resolveAgent(agentId: string) {
+    return this.request<{
+      cliCmd: string;
+      cliType: string;
+      supportsSession: boolean;
+      env?: Record<string, string>;
+      model?: string;
+      resumeFlag?: string;
+    }>(`/api/agents?resolve=${encodeURIComponent(agentId)}`);
+  }
+
+  /** Find a workspace by project path (returns null if none). */
+  findWorkspaceByPath(projectPath: string) {
+    return this.request<any>(`/api/workspace?projectPath=${encodeURIComponent(projectPath)}`);
+  }
+
+  /** Generic workspace daemon action — POST /api/workspace/<id>/agents { action, ... } */
+  wsAction(workspaceId: string, action: string, body: Record<string, any> = {}) {
+    return this.request<any>(`/api/workspace/${workspaceId}/agents`, {
+      method: 'POST',
+      body: JSON.stringify({ action, ...body }),
+    });
+  }
+
+  /** Smith-scoped action — POST /api/workspace/<id>/smith { action, agentId, ... } */
+  smithAction(workspaceId: string, action: string, agentId: string, body: Record<string, any> = {}) {
+    return this.request<any>(`/api/workspace/${workspaceId}/smith`, {
+      method: 'POST',
+      body: JSON.stringify({ action, agentId, ...body }),
+    });
+  }
+
+  /** List pipeline runs (instances of started workflows), newest first. */
+  listPipelines() { return this.request<any[]>('/api/pipelines'); }
+
+  /** List available workflow templates (the YAMLs you can start as pipelines). */
+  listWorkflows() { return this.request<any[]>('/api/pipelines?type=workflows'); }
+
+  /** Fetch a single pipeline run by id (includes per-node status + errors). */
+  getPipeline(id: string) {
+    return this.request<any>(`/api/pipelines/${id}`);
+  }
+
+  /** Fetch a single task by id. Returns prompt, log, resultSummary, error, gitDiff. */
+  getTask(id: string) {
+    return this.request<any>(`/api/tasks/${id}`);
+  }
+
+  /** Start a pipeline run from a workflow template. */
+  startPipeline(workflow: string, input: Record<string, string> = {}) {
+    return this.request<any>('/api/pipelines', {
+      method: 'POST',
+      body: JSON.stringify({ workflow, input }),
+    });
+  }
+
+  /** Project-pipeline bindings: workflows attached to a specific project, with
+   *  optional schedule / config. Returns { bindings, runs, workflows }. */
+  getProjectPipelines(projectPath: string) {
+    return this.request<{ bindings: any[]; runs: any[]; workflows: any[] }>(
+      `/api/project-pipelines?project=${encodeURIComponent(projectPath)}`,
+    );
+  }
+
+  /** Trigger a binding to run now. */
+  triggerProjectPipeline(projectPath: string, projectName: string, workflowName: string, input: Record<string, string> = {}) {
+    return this.request<any>('/api/project-pipelines', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'trigger', projectPath, projectName, workflowName, input }),
+    });
+  }
+
+  /** Add a workflow as a pipeline binding to a project. */
+  addProjectPipeline(projectPath: string, projectName: string, workflowName: string, config: Record<string, any> = {}) {
+    return this.request<any>('/api/project-pipelines', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'add', projectPath, projectName, workflowName, config }),
+    });
+  }
+
+  /** Enable/disable a binding without removing it. */
+  updateProjectPipeline(projectPath: string, workflowName: string, opts: { enabled?: boolean; config?: Record<string, any> }) {
+    return this.request<any>('/api/project-pipelines', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'update', projectPath, workflowName, ...opts }),
+    });
+  }
+
+  /** Remove a binding from a project. */
+  removeProjectPipeline(projectPath: string, workflowName: string) {
+    return this.request<any>('/api/project-pipelines', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'remove', projectPath, workflowName }),
+    });
+  }
+
+  /** List forge's user-configured doc roots and their file trees. */
+  listDocs() {
+    return this.request<{
+      roots: string[];
+      rootPaths: string[];
+      tree: any[];
+    }>('/api/docs');
+  }
+
+
+  createTask(projectName: string, prompt: string, opts?: { newSession?: boolean }) {
+    return this.request<any>('/api/tasks', {
+      method: 'POST',
+      body: JSON.stringify({ project: projectName, prompt, ...opts }),
+    });
+  }
+}

package/vscode-extension/src/auth/auth.ts

@@ -0,0 +1,32 @@
+import * as vscode from 'vscode';
+
+const KEY_PREFIX = 'forge.token.';
+const LEGACY_KEY = 'forge.adminToken';
+
+/** Per-connection token storage backed by VSCode SecretStorage. */
+export class Auth {
+  constructor(private secrets: vscode.SecretStorage) {}
+
+  async getToken(connectionName: string): Promise<string | undefined> {
+    return this.secrets.get(KEY_PREFIX + connectionName);
+  }
+
+  async setToken(connectionName: string, token: string): Promise<void> {
+    await this.secrets.store(KEY_PREFIX + connectionName, token);
+  }
+
+  async clearToken(connectionName: string): Promise<void> {
+    await this.secrets.delete(KEY_PREFIX + connectionName);
+  }
+
+  /** One-shot migration of the legacy single-token storage to the new
+   *  per-connection key. Run on extension activation. */
+  async migrateLegacy(defaultName: string): Promise<void> {
+    const legacy = await this.secrets.get(LEGACY_KEY);
+    if (!legacy) return;
+    if (!(await this.getToken(defaultName))) {
+      await this.setToken(defaultName, legacy);
+    }
+    await this.secrets.delete(LEGACY_KEY);
+  }
+}

package/vscode-extension/src/commands/auth.ts

@@ -0,0 +1,44 @@
+import * as vscode from 'vscode';
+import { ForgeClient } from '../api/client';
+
+export async function loginCommand(client: ForgeClient): Promise<void> {
+  const reachable = await client.ping();
+  if (!reachable) {
+    const choice = await vscode.window.showWarningMessage(
+      'Cannot reach Forge server. Make sure it is running.',
+      'Start Server',
+      'Open Settings',
+      'Cancel',
+    );
+    if (choice === 'Start Server') {
+      vscode.commands.executeCommand('forge.startServer');
+      return;
+    }
+    if (choice === 'Open Settings') {
+      vscode.commands.executeCommand('workbench.action.openSettings', '@ext:aion0.forge-vscode');
+      return;
+    }
+    return;
+  }
+
+  const password = await vscode.window.showInputBox({
+    prompt: 'Forge admin password',
+    password: true,
+    ignoreFocusOut: true,
+  });
+  if (!password) return;
+
+  const result = await client.login(password);
+  if (result.ok) {
+    vscode.window.showInformationMessage('Forge: logged in');
+    vscode.commands.executeCommand('forge.refresh');
+  } else {
+    vscode.window.showErrorMessage(`Forge login failed: ${result.error}`);
+  }
+}
+
+export async function logoutCommand(client: ForgeClient): Promise<void> {
+  await client.logout();
+  vscode.window.showInformationMessage('Forge: logged out');
+  vscode.commands.executeCommand('forge.refresh');
+}

package/vscode-extension/src/commands/connection.ts

@@ -0,0 +1,113 @@
+import * as vscode from 'vscode';
+import { ConnectionManager, ForgeConnection } from '../connection/manager';
+
+const ADD_NEW = '$(add) Add New Connection…';
+
+export async function switchConnectionCommand(mgr: ConnectionManager): Promise<void> {
+  const list = mgr.list();
+  const active = mgr.active();
+  const items: vscode.QuickPickItem[] = list.map(c => ({
+    label: c.name === active.name ? `$(circle-large-filled) ${c.name}` : `$(circle-large-outline) ${c.name}`,
+    description: c.serverUrl,
+  }));
+  items.push({ label: '', kind: vscode.QuickPickItemKind.Separator });
+  items.push({ label: ADD_NEW });
+
+  const picked = await vscode.window.showQuickPick(items, {
+    placeHolder: `Switch forge connection (current: ${active.name})`,
+  });
+  if (!picked) return;
+
+  if (picked.label === ADD_NEW) {
+    return addConnectionCommand(mgr, true);
+  }
+  // Strip the icon prefix to get the actual name.
+  const name = picked.label.replace(/^\$\([^)]+\)\s+/, '');
+  if (name === active.name) return;
+  await mgr.setActive(name);
+  vscode.window.showInformationMessage(`Forge: switched to "${name}"`);
+}
+
+export async function addConnectionCommand(mgr: ConnectionManager, switchAfter = false): Promise<void> {
+  const name = await vscode.window.showInputBox({
+    prompt: 'Connection name',
+    placeHolder: 'e.g. Office, Cloud, Staging',
+    ignoreFocusOut: true,
+    validateInput: v => {
+      if (!v.trim()) return 'Name required';
+      if (mgr.list().some(c => c.name === v.trim())) return 'Name already used';
+      return null;
+    },
+  });
+  if (!name) return;
+
+  const serverUrl = await vscode.window.showInputBox({
+    prompt: 'Forge HTTP URL',
+    value: 'http://',
+    placeHolder: 'http://1.2.3.4:8403  or  https://forge.example.com',
+    ignoreFocusOut: true,
+    validateInput: v => v.startsWith('http://') || v.startsWith('https://') ? null : 'Must start with http:// or https://',
+  });
+  if (!serverUrl) return;
+
+  // Reasonable terminal URL guess: same host, +1 port if on 8403; user can override.
+  const guessedTerminal = guessTerminalUrl(serverUrl);
+  const terminalUrl = await vscode.window.showInputBox({
+    prompt: 'Terminal WebSocket URL',
+    value: guessedTerminal,
+    placeHolder: 'ws://1.2.3.4:8404',
+    ignoreFocusOut: true,
+    validateInput: v => v.startsWith('ws://') || v.startsWith('wss://') ? null : 'Must start with ws:// or wss://',
+  });
+  if (!terminalUrl) return;
+
+  const conn: ForgeConnection = { name: name.trim(), serverUrl: serverUrl.trim(), terminalUrl: terminalUrl.trim() };
+  try {
+    await mgr.add(conn);
+  } catch (e: any) {
+    vscode.window.showErrorMessage(`Forge: ${e.message}`);
+    return;
+  }
+  vscode.window.showInformationMessage(`Forge: added "${conn.name}"`);
+  if (switchAfter) {
+    await mgr.setActive(conn.name);
+  }
+}
+
+export async function removeConnectionCommand(mgr: ConnectionManager): Promise<void> {
+  const list = mgr.list();
+  if (list.length <= 1) {
+    vscode.window.showWarningMessage('Forge: cannot remove the last connection.');
+    return;
+  }
+  const picked = await vscode.window.showQuickPick(
+    list.map(c => ({ label: c.name, description: c.serverUrl, name: c.name })),
+    { placeHolder: 'Remove which connection?' },
+  );
+  if (!picked) return;
+  const confirm = await vscode.window.showWarningMessage(
+    `Remove connection "${picked.name}"? Saved token will be cleared.`,
+    'Remove', 'Cancel',
+  );
+  if (confirm !== 'Remove') return;
+  await mgr.remove(picked.name);
+  vscode.window.showInformationMessage(`Forge: removed "${picked.name}"`);
+}
+
+export async function editConnectionsCommand(): Promise<void> {
+  await vscode.commands.executeCommand('workbench.action.openSettingsJson');
+  vscode.window.showInformationMessage('Forge: edit `forge.connections` in settings.json');
+}
+
+function guessTerminalUrl(serverUrl: string): string {
+  try {
+    const u = new URL(serverUrl);
+    const proto = u.protocol === 'https:' ? 'wss:' : 'ws:';
+    let port = parseInt(u.port || (u.protocol === 'https:' ? '443' : '80'), 10);
+    // forge default: HTTP=8403 → terminal=8404. If port is HTTP-style + 1.
+    if (port === 8403) port = 8404;
+    return `${proto}//${u.hostname}:${port}`;
+  } catch {
+    return 'ws://localhost:8404';
+  }
+}

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

@@ -0,0 +1,40 @@
+import * as vscode from 'vscode';
+import { join } from 'node:path';
+import { ForgeClient } from '../api/client';
+import { ForgePty } from '../terminal/pseudoterm';
+import { buildDocUri } from '../docs/fs-provider';
+import { detectDocsTransport } from '../docs/transport';
+
+/** Open a doc file. In local mode, hand VSCode the on-disk path so it's
+ *  treated as a regular file. In remote (http) mode, use the forge-docs://
+ *  FileSystemProvider so reads/writes go through forge's HTTP API. */
+export async function openDocCommand(
+  _client: ForgeClient,
+  arg?: { rootIdx: number; rootPath?: string; path: string; fileType?: string; name?: string },
+): Promise<void> {
+  if (!arg?.path) return;
+  const transport = detectDocsTransport();
+
+  let uri: vscode.Uri;
+  if (transport === 'local' && arg.rootPath) {
+    uri = vscode.Uri.file(join(arg.rootPath, arg.path));
+  } else {
+    uri = buildDocUri(arg.rootIdx, arg.path);
+  }
+
+  await vscode.commands.executeCommand('vscode.open', uri);
+}
+
+/** Open a forge terminal cd'd into a directory — the docRoot or any subdir.
+ *  Always goes through the forge terminal WebSocket, so works for remote
+ *  forges too (tmux runs on the forge host, not the local VSCode machine). */
+export async function openDocsTerminalCommand(client: ForgeClient, arg?: { rootIdx?: number; rootPath?: string; rootName?: string; path?: string }): Promise<void> {
+  if (!arg?.rootPath) return;
+  // For sub-dirs, use rootPath joined with the relative `path`.
+  const cwd = arg.path ? `${arg.rootPath}/${arg.path}` : arg.rootPath;
+  const terminalLabel = arg.path ? `${arg.rootName || 'docs'}/${arg.path.split('/').pop()}` : (arg.rootName || 'docs');
+  const launchCommand = `cd "${cwd}" && claude --dangerously-skip-permissions`;
+  const pty = new ForgePty({ url: client.terminalUrl, cwd, launchCommand });
+  const term = vscode.window.createTerminal({ name: `forge: ${terminalLabel}`, pty });
+  term.show();
+}

package/vscode-extension/src/commands/pipeline.ts

@@ -0,0 +1,103 @@
+import * as vscode from 'vscode';
+import { ForgeClient } from '../api/client';
+
+interface PipelineArg {
+  projectPath?: string;
+  projectName?: string;
+  workflowName?: string;
+}
+
+/** Pick a project (if not given), then a workflow, then add the binding. */
+export async function addPipelineCommand(client: ForgeClient, arg?: PipelineArg): Promise<void> {
+  let projectPath = arg?.projectPath;
+  let projectName = arg?.projectName;
+
+  if (!projectPath) {
+    const projRes = await client.listProjects();
+    const projects: any[] = projRes.ok && Array.isArray(projRes.data) ? projRes.data : [];
+    if (projects.length === 0) {
+      vscode.window.showWarningMessage('Forge: no projects configured.');
+      return;
+    }
+    const pickedProj = await vscode.window.showQuickPick(
+      projects.map(p => ({ label: p.name, description: p.path, project: p })),
+      { placeHolder: 'Add pipeline to which project?' },
+    );
+    if (!pickedProj) return;
+    projectPath = pickedProj.project.path;
+    projectName = pickedProj.project.name;
+  }
+
+  // Fetch workflows + existing bindings to filter out duplicates.
+  const projPipes = await client.getProjectPipelines(projectPath!);
+  const allWorkflows: any[] = projPipes.ok ? (projPipes.data?.workflows || []) : [];
+  const bindings: any[] = projPipes.ok ? (projPipes.data?.bindings || []) : [];
+  const bound = new Set(bindings.map((b: any) => b.workflowName));
+  const candidates = allWorkflows.filter((w: any) => !bound.has(w.name));
+
+  if (candidates.length === 0) {
+    vscode.window.showInformationMessage('Forge: no more workflows to add (all are already bound).');
+    return;
+  }
+
+  const picked = await vscode.window.showQuickPick(
+    candidates.map((w: any) => ({
+      label: w.name,
+      description: w.builtin ? 'built-in' : 'user',
+      detail: w.description || '',
+      workflow: w,
+    })),
+    { placeHolder: 'Workflow to bind' },
+  );
+  if (!picked) return;
+
+  const r = await client.addProjectPipeline(projectPath!, projectName!, picked.workflow.name, {});
+  if (r.ok) {
+    vscode.window.showInformationMessage(`Forge: added "${picked.workflow.name}" to ${projectName}`);
+    vscode.commands.executeCommand('forge.refresh');
+  } else {
+    vscode.window.showErrorMessage(`Forge: add pipeline failed — ${r.error}`);
+  }
+}
+
+/** Trigger a binding to run once. */
+export async function triggerPipelineCommand(client: ForgeClient, arg?: PipelineArg): Promise<void> {
+  if (!arg?.projectPath || !arg.projectName || !arg.workflowName) return;
+  const r = await client.triggerProjectPipeline(arg.projectPath, arg.projectName, arg.workflowName, {});
+  if (r.ok) {
+    vscode.window.showInformationMessage(`Forge: triggered "${arg.workflowName}"${r.data?.id ? ' (run ' + r.data.id.slice(0, 8) + ')' : ''}`);
+    vscode.commands.executeCommand('forge.refresh');
+  } else {
+    vscode.window.showErrorMessage(`Forge: trigger failed — ${r.error}`);
+  }
+}
+
+/** Toggle enable/disable on a binding. The argument carries current `enabled`. */
+export async function togglePipelineCommand(client: ForgeClient, arg?: PipelineArg & { enabled?: boolean }): Promise<void> {
+  if (!arg?.projectPath || !arg.workflowName) return;
+  const next = !arg.enabled;
+  const r = await client.updateProjectPipeline(arg.projectPath, arg.workflowName, { enabled: next });
+  if (r.ok) {
+    vscode.window.showInformationMessage(`Forge: "${arg.workflowName}" ${next ? 'enabled' : 'disabled'}`);
+    vscode.commands.executeCommand('forge.refresh');
+  } else {
+    vscode.window.showErrorMessage(`Forge: toggle failed — ${r.error}`);
+  }
+}
+
+/** Remove a binding from a project. */
+export async function removePipelineCommand(client: ForgeClient, arg?: PipelineArg): Promise<void> {
+  if (!arg?.projectPath || !arg.workflowName) return;
+  const choice = await vscode.window.showWarningMessage(
+    `Remove pipeline "${arg.workflowName}" from ${arg.projectName}?`,
+    'Remove', 'Cancel',
+  );
+  if (choice !== 'Remove') return;
+  const r = await client.removeProjectPipeline(arg.projectPath, arg.workflowName);
+  if (r.ok) {
+    vscode.window.showInformationMessage(`Forge: removed "${arg.workflowName}"`);
+    vscode.commands.executeCommand('forge.refresh');
+  } else {
+    vscode.window.showErrorMessage(`Forge: remove failed — ${r.error}`);
+  }
+}

package/vscode-extension/src/commands/server.ts

@@ -0,0 +1,50 @@
+import * as vscode from 'vscode';
+import { spawn } from 'node:child_process';
+import { ForgeClient } from '../api/client';
+
+export async function startServerCommand(client: ForgeClient): Promise<void> {
+  if (await client.ping()) {
+    vscode.window.showInformationMessage('Forge: server already running.');
+    return;
+  }
+  const proc = spawn('forge', ['server', 'start'], {
+    detached: true,
+    stdio: 'ignore',
+    env: process.env,
+  });
+  proc.on('error', (err) => {
+    vscode.window.showErrorMessage(`Forge: failed to start (${err.message}). Is the 'forge' CLI on PATH?`);
+  });
+  proc.unref();
+
+  // Poll for up to 30s
+  const start = Date.now();
+  while (Date.now() - start < 30_000) {
+    await new Promise(r => setTimeout(r, 1000));
+    if (await client.ping()) {
+      vscode.window.showInformationMessage('Forge: server started.');
+      vscode.commands.executeCommand('forge.refresh');
+      return;
+    }
+  }
+  vscode.window.showWarningMessage('Forge: started but not yet reachable. Try Forge: Refresh in a moment.');
+}
+
+export async function stopServerCommand(): Promise<void> {
+  const choice = await vscode.window.showWarningMessage(
+    'Stop the Forge server? Active terminals and tasks will be terminated.',
+    'Stop', 'Cancel',
+  );
+  if (choice !== 'Stop') return;
+
+  const proc = spawn('forge', ['server', 'stop'], { stdio: 'ignore', env: process.env });
+  proc.on('error', (err) => {
+    vscode.window.showErrorMessage(`Forge stop failed: ${err.message}`);
+  });
+  vscode.window.showInformationMessage('Forge: stop signal sent.');
+}
+
+export function openWebUICommand(client: ForgeClient): void {
+  const url = vscode.workspace.getConfiguration('forge').get<string>('serverUrl', 'http://localhost:8403');
+  vscode.env.openExternal(vscode.Uri.parse(url));
+}