@aion0/forge 0.5.44 → 0.5.47

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

@@ -1,112 +0,0 @@
-import * as vscode from 'vscode';
-import { ForgeClient } from '../api/client';
-import { ForgePty } from '../terminal/pseudoterm';
-
-export interface SmithArg {
-  workspaceId: string;
-  agentId: string;
-  label?: string;
-}
-
-/** Cache of VSCode terminals we created, keyed by tmux session name. Reusing
- *  prevents N duplicate panes when the user clicks the same smith repeatedly.
- *  Entries are removed on terminal close (see registerSmithTerminalCleanup). */
-const openedTerminals = new Map<string, vscode.Terminal>();
-
-/** Wire VSCode's terminal-close event so we drop stale cache entries. Called
- *  once from extension activation. */
-export function registerSmithTerminalCleanup(context: vscode.ExtensionContext): void {
-  context.subscriptions.push(vscode.window.onDidCloseTerminal((t) => {
-    for (const [key, term] of openedTerminals) {
-      if (term === t) {
-        openedTerminals.delete(key);
-        break;
-      }
-    }
-  }));
-}
-
-/** Open a smith's tmux session in VSCode terminal panel. If we already opened
- *  it earlier, just .show() the existing pane instead of creating a new one. */
-export async function smithOpenTerminalCommand(client: ForgeClient, arg?: SmithArg): Promise<void> {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'open_terminal', { agentId: arg.agentId });
-  if (!r.ok) {
-    vscode.window.showErrorMessage(`Forge: open terminal failed — ${r.error}`);
-    return;
-  }
-  const tmuxSession: string | undefined = r.data?.tmuxSession;
-  if (!tmuxSession) {
-    vscode.window.showErrorMessage(`Forge: smith ${arg.label || arg.agentId} has no tmux session yet — try Start Daemon first.`);
-    return;
-  }
-
-  const existing = openedTerminals.get(tmuxSession);
-  if (existing) {
-    existing.show();
-    return;
-  }
-
-  const pty = new ForgePty({ url: client.terminalUrl, attach: tmuxSession });
-  const term = vscode.window.createTerminal({ name: `forge: ${arg.label || arg.agentId}`, pty });
-  openedTerminals.set(tmuxSession, term);
-  term.show();
-}
-
-// ── Lifecycle actions ──────────────────────────────────
-
-export async function smithPauseCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'pause', { agentId: arg.agentId });
-  reportResult('Pause', r);
-}
-
-export async function smithResumeCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'resume', { agentId: arg.agentId });
-  reportResult('Resume', r);
-}
-
-export async function smithMarkDoneCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'mark_done', { agentId: arg.agentId, notify: true });
-  reportResult('Mark Done', r);
-}
-
-export async function smithMarkFailedCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'mark_failed', { agentId: arg.agentId, notify: true });
-  reportResult('Mark Failed', r);
-}
-
-export async function smithMarkIdleCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'mark_done', { agentId: arg.agentId, notify: false });
-  reportResult('Mark Idle', r);
-}
-
-export async function smithRetryCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const r = await client.wsAction(arg.workspaceId, 'retry', { agentId: arg.agentId });
-  reportResult('Retry', r);
-}
-
-export async function smithSendMessageCommand(client: ForgeClient, arg?: SmithArg) {
-  if (!arg) return;
-  const content = await vscode.window.showInputBox({
-    prompt: `Send message to ${arg.label || arg.agentId}`,
-    placeHolder: 'Type your instruction…',
-    ignoreFocusOut: true,
-  });
-  if (!content) return;
-  const r = await client.wsAction(arg.workspaceId, 'message', { agentId: arg.agentId, content });
-  reportResult('Send Message', r);
-}
-
-function reportResult(action: string, r: { ok: boolean; error?: string }) {
-  if (r.ok) {
-    vscode.commands.executeCommand('forge.refresh');
-  } else {
-    vscode.window.showErrorMessage(`Forge: ${action} failed — ${r.error}`);
-  }
-}

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

@@ -1,43 +0,0 @@
-import * as vscode from 'vscode';
-import { ForgeClient } from '../api/client';
-
-export async function newTaskCommand(client: ForgeClient): Promise<void> {
-  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. Add one in Settings → Project Roots.');
-    return;
-  }
-
-  const projItems = projects.map(p => ({
-    label: p.name,
-    description: p.path,
-    project: p,
-  }));
-  const proj = await vscode.window.showQuickPick(projItems, { placeHolder: 'Project for this task' });
-  if (!proj) return;
-
-  const prompt = await vscode.window.showInputBox({
-    prompt: `Task prompt for ${proj.label}`,
-    placeHolder: 'e.g. Add unit tests for the auth module',
-    ignoreFocusOut: true,
-  });
-  if (!prompt) return;
-
-  const newSessionPick = await vscode.window.showQuickPick(
-    [
-      { label: 'Continue last session', value: false },
-      { label: 'Fresh session', value: true },
-    ],
-    { placeHolder: 'Session mode' },
-  );
-  if (newSessionPick === undefined) return;
-
-  const r = await client.createTask(proj.label, prompt, { newSession: newSessionPick.value });
-  if (r.ok) {
-    vscode.window.showInformationMessage(`Forge: task queued${r.data?.id ? ' (id ' + r.data.id + ')' : ''}.`);
-    vscode.commands.executeCommand('forge.refresh');
-  } else {
-    vscode.window.showErrorMessage(`Forge: failed to queue task — ${r.error}`);
-  }
-}

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

@@ -1,279 +0,0 @@
-import * as vscode from 'vscode';
-import { ForgeClient } from '../api/client';
-import { ForgePty } from '../terminal/pseudoterm';
-
-export async function openTerminalCommand(client: ForgeClient): Promise<void> {
-  const reachable = await client.ping();
-  if (!reachable) {
-    vscode.window.showErrorMessage('Forge: server unreachable. Run "Forge: Start Server" or check settings.');
-    return;
-  }
-
-  // Pick: attach to existing session, or create a new one for a project
-  const termsRes = await client.listTerminals();
-  const terms: any[] = termsRes.ok && termsRes.data
-    ? (Array.isArray(termsRes.data) ? termsRes.data : (termsRes.data.sessions || []))
-    : [];
-  const projRes = await client.listProjects();
-  const projects: any[] = projRes.ok && Array.isArray(projRes.data) ? projRes.data : [];
-
-  interface OpenPickItem extends vscode.QuickPickItem {
-    action: 'attach' | 'create';
-    sessionName?: string;
-    projectPath?: string;
-  }
-  const items: OpenPickItem[] = [];
-
-  for (const t of terms) {
-    const name = t.name || t.sessionName;
-    if (!name) continue;
-    items.push({
-      label: `$(terminal) ${name}`,
-      description: t.projectPath ? `attach · ${t.projectPath}` : 'attach',
-      action: 'attach',
-      sessionName: name,
-    });
-  }
-  for (const p of projects) {
-    items.push({
-      label: `$(plus) New terminal in ${p.name}`,
-      description: p.path,
-      action: 'create',
-      projectPath: p.path,
-    });
-  }
-
-  if (items.length === 0) {
-    vscode.window.showInformationMessage('Forge: no projects configured. Add one in Settings → Project Roots.');
-    return;
-  }
-
-  const picked = await vscode.window.showQuickPick(items, { placeHolder: 'Attach or create a Forge terminal' });
-  if (!picked) return;
-
-  if (picked.action === 'attach' && picked.sessionName) {
-    attachTerminalImpl(client, picked.sessionName);
-  } else if (picked.action === 'create' && picked.projectPath) {
-    return openSessionCommand(client, { projectPath: picked.projectPath, projectName: picked.projectPath.split('/').pop() });
-  }
-}
-
-export async function attachTerminalCommand(client: ForgeClient, arg?: { sessionName?: string }): Promise<void> {
-  if (!arg?.sessionName) {
-    return openTerminalCommand(client);
-  }
-  attachTerminalImpl(client, arg.sessionName);
-}
-
-function attachTerminalImpl(client: ForgeClient, sessionName: string): void {
-  const pty = new ForgePty({ url: client.terminalUrl, attach: sessionName });
-  const term = vscode.window.createTerminal({ name: `forge: ${sessionName}`, pty });
-  term.show();
-}
-
-/** Open a forge session picker for a project — same flow as web UI's terminal picker:
- *  Agent → Current Session / New Session / Other Session. Then launches the chosen
- *  agent in a tmux. */
-export async function openSessionCommand(client: ForgeClient, arg?: { projectPath?: string; projectName?: string; agentId?: string }): Promise<void> {
-  let projectPath = arg?.projectPath;
-  let projectName = arg?.projectName;
-  let agentId = arg?.agentId;
-
-  if (!projectPath) {
-    const projRes = await client.listProjects();
-    const projects: any[] = projRes.ok && Array.isArray(projRes.data) ? projRes.data : [];
-    if (projects.length === 0) {
-      vscode.window.showInformationMessage('Forge: no projects configured. Add one in Settings → Project Roots.');
-      return;
-    }
-    const picked = await vscode.window.showQuickPick(
-      projects.map(p => ({ label: p.name, description: p.path, project: p })),
-      { placeHolder: 'Select project' },
-    );
-    if (!picked) return;
-    projectPath = picked.project.path;
-    projectName = picked.project.name;
-  }
-  if (!projectName && projectPath) projectName = projectPath.split('/').pop();
-
-  // Pick agent if not provided — only ask when there are 2+ enabled agents.
-  if (!agentId) {
-    const agentsRes = await client.listAgents();
-    const allAgents: any[] = agentsRes.ok && Array.isArray(agentsRes.data?.agents) ? agentsRes.data!.agents : [];
-    const defaultAgent = agentsRes.ok ? agentsRes.data?.defaultAgent : undefined;
-    const enabled = allAgents.filter(a => a.enabled !== false);
-    if (enabled.length === 0) {
-      // Fall back to claude if nothing detected — better than refusing.
-      agentId = 'claude';
-    } else if (enabled.length === 1) {
-      agentId = enabled[0].id;
-    } else {
-      // Place default first, then the rest.
-      const sorted = [
-        ...enabled.filter(a => a.id === defaultAgent),
-        ...enabled.filter(a => a.id !== defaultAgent),
-      ];
-      const picks = sorted.map(a => ({
-        label: `${iconForAgent(a.cliType || a.type)} ${a.name || a.id}`,
-        description: a.id === defaultAgent ? 'default' : (a.cliType || a.type || ''),
-        detail: a.path && a.path !== a.id ? a.path : undefined,
-        agent: a,
-      }));
-      const sel = await vscode.window.showQuickPick(picks, { placeHolder: 'Select agent' });
-      if (!sel) return;
-      agentId = sel.agent.id;
-    }
-  }
-
-  // Resolve agent launch info — gives us cliCmd, supportsSession, model, env.
-  const resolveRes = await client.resolveAgent(agentId!);
-  const cliCmd          = resolveRes.ok ? (resolveRes.data?.cliCmd || 'claude')          : 'claude';
-  const supportsSession = resolveRes.ok ? (resolveRes.data?.supportsSession ?? true)     : true;
-  const cliType         = resolveRes.ok ? (resolveRes.data?.cliType || 'claude-code')    : 'claude-code';
-  const model           = resolveRes.ok ? resolveRes.data?.model                          : undefined;
-  const env             = resolveRes.ok ? (resolveRes.data?.env || {})                    : {};
-
-  // Resolve the project's bound fixedSession (if any). Only meaningful when
-  // the agent supports --resume.
-  let fixedSessionId: string | null = null;
-  if (supportsSession) {
-    try {
-      const r = await client.getProjectSession(projectPath!);
-      if (r.ok && r.data?.fixedSessionId) fixedSessionId = r.data.fixedSessionId;
-    } catch {}
-  }
-
-  // For agents that don't support --resume (codex, aider, custom), skip the
-  // session picker entirely — there's nothing to resume.
-  let resumeId: string | null = null;
-  if (supportsSession) {
-    interface SessionPick extends vscode.QuickPickItem {
-      mode: 'current' | 'new' | 'other';
-    }
-    const picks: SessionPick[] = [];
-    if (fixedSessionId) {
-      picks.push({
-        label: `$(circle-large-filled) Current Session`,
-        description: fixedSessionId.slice(0, 16) + '…',
-        detail: 'Resume the bound session for this project',
-        mode: 'current',
-      });
-    }
-    picks.push({
-      label: `$(add) New Session`,
-      detail: `Start a fresh ${cliCmd} session`,
-      mode: 'new',
-    });
-    if (cliType === 'claude-code') {
-      // Only claude-code has on-disk session files we can list.
-      picks.push({
-        label: `$(history) Other Session…`,
-        detail: 'Pick from recent claude sessions for this project',
-        mode: 'other',
-      });
-    }
-
-    const choice = await vscode.window.showQuickPick(picks, {
-      placeHolder: `Open ${projectName} (${cliCmd}) — choose a session`,
-    });
-    if (!choice) return;
-
-    if (choice.mode === 'current' && fixedSessionId) {
-      resumeId = fixedSessionId;
-    } else if (choice.mode === 'other') {
-      if (!projectName) return;
-      const sessRes = await client.listClaudeSessions(projectName);
-      const sessions: any[] = sessRes.ok && Array.isArray(sessRes.data) ? sessRes.data : [];
-      if (sessions.length === 0) {
-        vscode.window.showInformationMessage(`Forge: no past sessions found for ${projectName}.`);
-        return;
-      }
-      const otherPicks = sessions.map((s: any, i: number) => {
-        const sid = s.sessionId || s.id || '';
-        const date = s.modified ? new Date(s.modified).toLocaleString() : '';
-        const isCurrent = sid === fixedSessionId;
-        const isLatest = i === 0;
-        const tag = isCurrent ? ' (current)' : isLatest ? ' (latest)' : '';
-        return {
-          label: `$(comment-discussion) ${sid.slice(0, 16)}…${tag}`,
-          description: date,
-          sessionId: sid,
-        };
-      });
-      const sel = await vscode.window.showQuickPick(otherPicks, {
-        placeHolder: `Recent sessions in ${projectName}`,
-      });
-      if (!sel) return;
-      resumeId = sel.sessionId;
-    }
-    // mode === 'new' → resumeId stays null
-  }
-
-  // Build launch command. Only claude-code uses --dangerously-skip-permissions
-  // by default; other CLIs have their own (e.g. codex --full-auto) that we
-  // don't auto-add — user can configure their own settings.
-  const resumeFlag = resumeId ? ` --resume ${resumeId}` : '';
-  const modelFlag  = model ? ` --model ${model}` : '';
-  const skipFlag   = cliType === 'claude-code' ? ' --dangerously-skip-permissions' : '';
-  const envExports = Object.entries(env)
-    .filter(([k]) => k !== 'CLAUDE_MODEL') // model passed via --model
-    .map(([k, v]) => `export ${k}="${v}"`)
-    .join(' && ');
-  const envPrefix  = envExports ? envExports + ' && ' : '';
-  const launchCommand = `${envPrefix}cd "${projectPath}" && ${cliCmd}${resumeFlag}${modelFlag}${skipFlag}`;
-
-  const pty = new ForgePty({ url: client.terminalUrl, cwd: projectPath, launchCommand });
-  const label = projectName || 'forge';
-  const agentTag = cliCmd !== 'claude' ? ` (${cliCmd})` : '';
-  const term = vscode.window.createTerminal({ name: `forge: ${label}${agentTag}`, pty });
-  term.show();
-}
-
-function iconForAgent(cliType: string | undefined): string {
-  switch (cliType) {
-    case 'claude-code': return '$(comment-discussion)';
-    case 'codex':       return '$(zap)';
-    case 'aider':       return '$(edit)';
-    default:            return '$(robot)';
-  }
-}
-
-/** Backwards-compatible alias kept for the tree view "New Terminal" entries. */
-export const newTerminalCommand = openSessionCommand;
-
-export async function sendSelectionCommand(client: ForgeClient): Promise<void> {
-  const editor = vscode.window.activeTextEditor;
-  if (!editor || editor.selection.isEmpty) {
-    vscode.window.showWarningMessage('Forge: no text selected.');
-    return;
-  }
-  const text = editor.document.getText(editor.selection);
-
-  const termsRes = await client.listTerminals();
-  const terms: any[] = termsRes.ok && termsRes.data
-    ? (Array.isArray(termsRes.data) ? termsRes.data : (termsRes.data.sessions || []))
-    : [];
-  if (terms.length === 0) {
-    vscode.window.showInformationMessage('Forge: no active terminals.');
-    return;
-  }
-  const items: (vscode.QuickPickItem & { name: string })[] = terms
-    .map((t: any) => ({
-      label: `$(terminal) ${t.name || t.sessionName}`,
-      description: t.projectPath || '',
-      name: t.name || t.sessionName,
-    }))
-    .filter(i => i.name);
-  const picked = await vscode.window.showQuickPick(items, { placeHolder: 'Send selection to which terminal?' });
-  if (!picked) return;
-
-  const r = await client.request(`/api/terminal/inject`, {
-    method: 'POST',
-    body: JSON.stringify({ sessionName: picked.name, text }),
-  });
-  if (r.ok) {
-    vscode.window.showInformationMessage(`Forge: sent ${text.length} chars to ${picked.name}`);
-  } else {
-    vscode.window.showErrorMessage(`Forge inject failed: ${r.error}`);
-  }
-}

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

@@ -1,138 +0,0 @@
-import * as vscode from 'vscode';
-import { ForgeClient } from '../api/client';
-
-/** Open the forge workspace bound to the current VSCode folder.
- *  - If found: focus the forge sidebar so the user sees it.
- *  - If not found: ask whether to create one. */
-export async function openWorkspaceForFolderCommand(client: ForgeClient): Promise<void> {
-  const folders = vscode.workspace.workspaceFolders;
-  if (!folders || folders.length === 0) {
-    vscode.window.showWarningMessage('Forge: no folder open in VSCode.');
-    return;
-  }
-
-  // If user has multiple folders, ask which.
-  let folder = folders[0];
-  if (folders.length > 1) {
-    const picked = await vscode.window.showQuickPick(
-      folders.map(f => ({ label: f.name, description: f.uri.fsPath, folder: f })),
-      { placeHolder: 'Which folder?' },
-    );
-    if (!picked) return;
-    folder = picked.folder;
-  }
-
-  const projectPath = folder.uri.fsPath;
-  const r = await client.findWorkspaceByPath(projectPath);
-
-  if (r.ok && r.data) {
-    // Existing workspace — focus the sidebar.
-    vscode.commands.executeCommand('workbench.view.extension.forge');
-    vscode.commands.executeCommand('forge.refresh');
-    vscode.window.setStatusBarMessage(`Forge: ${r.data.projectName} workspace ready`, 3000);
-    return;
-  }
-
-  // No workspace yet — offer to create one.
-  const choice = await vscode.window.showInformationMessage(
-    `No forge workspace for ${folder.name}. Create one?`,
-    'Create', 'Cancel',
-  );
-  if (choice !== 'Create') return;
-
-  const create = await client.request('/api/workspace', {
-    method: 'POST',
-    body: JSON.stringify({ projectPath, projectName: folder.name }),
-  });
-  if (create.ok) {
-    vscode.window.showInformationMessage(`Forge: workspace created for ${folder.name}.`);
-    vscode.commands.executeCommand('workbench.view.extension.forge');
-    vscode.commands.executeCommand('forge.refresh');
-  } else {
-    vscode.window.showErrorMessage(`Forge: failed to create workspace — ${create.error}`);
-  }
-}
-
-/** Pick from the list of existing workspaces. */
-export async function openWorkspaceCommand(client: ForgeClient): Promise<void> {
-  const r = await client.listWorkspaces();
-  if (!r.ok || !Array.isArray(r.data) || r.data.length === 0) {
-    vscode.window.showInformationMessage('Forge: no workspaces yet. Use "Open Workspace for Current Folder" to create one.');
-    return;
-  }
-  const items = r.data.map((ws: any) => ({
-    label: ws.projectName || ws.id,
-    description: ws.projectPath || '',
-    detail: `${ws.agentCount || 0} smith(s)`,
-    workspace: ws,
-  }));
-  const picked = await vscode.window.showQuickPick(items, { placeHolder: 'Select a workspace' });
-  if (!picked) return;
-  vscode.commands.executeCommand('workbench.view.extension.forge');
-  vscode.commands.executeCommand('forge.refresh');
-}
-
-// ── Daemon control ──────────────────────────────────────
-
-export async function startDaemonCommand(client: ForgeClient, arg?: { workspaceId?: string }): Promise<void> {
-  const id = await resolveWorkspaceId(client, arg?.workspaceId);
-  if (!id) return;
-  const r = await client.wsAction(id, 'start_daemon');
-  if (r.ok) {
-    vscode.window.showInformationMessage('Forge: daemon starting…');
-    vscode.commands.executeCommand('forge.refresh');
-  } else {
-    vscode.window.showErrorMessage(`Forge: start daemon failed — ${r.error}`);
-  }
-}
-
-export async function stopDaemonCommand(client: ForgeClient, arg?: { workspaceId?: string }): Promise<void> {
-  const id = await resolveWorkspaceId(client, arg?.workspaceId);
-  if (!id) return;
-  const choice = await vscode.window.showWarningMessage(
-    'Stop the workspace daemon? Running smiths will be terminated.',
-    'Stop', 'Cancel',
-  );
-  if (choice !== 'Stop') return;
-  const r = await client.wsAction(id, 'stop_daemon');
-  if (r.ok) {
-    vscode.window.showInformationMessage('Forge: daemon stopped.');
-    vscode.commands.executeCommand('forge.refresh');
-  } else {
-    vscode.window.showErrorMessage(`Forge: stop daemon failed — ${r.error}`);
-  }
-}
-
-export async function restartDaemonCommand(client: ForgeClient, arg?: { workspaceId?: string }): Promise<void> {
-  const id = await resolveWorkspaceId(client, arg?.workspaceId);
-  if (!id) return;
-  const stop = await client.wsAction(id, 'stop_daemon');
-  if (!stop.ok) {
-    vscode.window.showErrorMessage(`Forge: restart failed at stop step — ${stop.error}`);
-    return;
-  }
-  // Brief settle
-  await new Promise(r => setTimeout(r, 800));
-  const start = await client.wsAction(id, 'start_daemon');
-  if (start.ok) {
-    vscode.window.showInformationMessage('Forge: daemon restarted.');
-    vscode.commands.executeCommand('forge.refresh');
-  } else {
-    vscode.window.showErrorMessage(`Forge: restart failed at start step — ${start.error}`);
-  }
-}
-
-async function resolveWorkspaceId(client: ForgeClient, given?: string): Promise<string | undefined> {
-  if (given) return given;
-  const r = await client.listWorkspaces();
-  if (!r.ok || !Array.isArray(r.data) || r.data.length === 0) {
-    vscode.window.showWarningMessage('Forge: no workspaces.');
-    return undefined;
-  }
-  if (r.data.length === 1) return r.data[0].id;
-  const picked = await vscode.window.showQuickPick(
-    r.data.map((ws: any) => ({ label: ws.projectName || ws.id, description: ws.projectPath, ws })),
-    { placeHolder: 'Which workspace?' },
-  );
-  return picked?.ws?.id;
-}

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

@@ -1,80 +0,0 @@
-import * as vscode from 'vscode';
-
-export interface ForgeConnection {
-  name: string;
-  serverUrl: string;
-  terminalUrl: string;
-}
-
-const CONFIG_NS = 'forge';
-
-/** Manages the user's saved forge connections and the active one.
- *  Persisted in VSCode's user settings (`forge.connections` + `forge.activeConnection`). */
-export class ConnectionManager {
-  private _onDidChange = new vscode.EventEmitter<ForgeConnection>();
-  onDidChange = this._onDidChange.event;
-
-  /** Listen for the user editing connections in settings.json so we can
-   *  refresh dependent state. */
-  watchConfig(context: vscode.ExtensionContext): void {
-    context.subscriptions.push(vscode.workspace.onDidChangeConfiguration(e => {
-      if (e.affectsConfiguration('forge.connections') || e.affectsConfiguration('forge.activeConnection')
-       || e.affectsConfiguration('forge.serverUrl') || e.affectsConfiguration('forge.terminalUrl')) {
-        this._onDidChange.fire(this.active());
-      }
-    }));
-  }
-
-  list(): ForgeConnection[] {
-    const cfg = vscode.workspace.getConfiguration(CONFIG_NS);
-    const conns = cfg.get<ForgeConnection[]>('connections', []);
-    if (conns && conns.length > 0) return conns;
-    // Backwards compat: synthesize "Local" from legacy single-server fields.
-    return [{
-      name: 'Local',
-      serverUrl: cfg.get<string>('serverUrl', 'http://localhost:8403'),
-      terminalUrl: cfg.get<string>('terminalUrl', 'ws://localhost:8404'),
-    }];
-  }
-
-  active(): ForgeConnection {
-    const all = this.list();
-    const cfg = vscode.workspace.getConfiguration(CONFIG_NS);
-    const name = cfg.get<string>('activeConnection');
-    return (name && all.find(c => c.name === name)) || all[0];
-  }
-
-  async setActive(name: string): Promise<void> {
-    await vscode.workspace.getConfiguration(CONFIG_NS)
-      .update('activeConnection', name, vscode.ConfigurationTarget.Global);
-    this._onDidChange.fire(this.active());
-  }
-
-  async add(c: ForgeConnection): Promise<void> {
-    const cfg = vscode.workspace.getConfiguration(CONFIG_NS);
-    let list = cfg.get<ForgeConnection[]>('connections', []);
-    if (list.length === 0) {
-      // Promote the synthesized Local entry so the user-set list is explicit.
-      list = this.list();
-    }
-    if (list.some(x => x.name === c.name)) {
-      throw new Error(`A connection named "${c.name}" already exists`);
-    }
-    list.push(c);
-    await cfg.update('connections', list, vscode.ConfigurationTarget.Global);
-    this._onDidChange.fire(this.active());
-  }
-
-  async remove(name: string): Promise<void> {
-    const cfg = vscode.workspace.getConfiguration(CONFIG_NS);
-    const list = cfg.get<ForgeConnection[]>('connections', []).filter(c => c.name !== name);
-    await cfg.update('connections', list, vscode.ConfigurationTarget.Global);
-    // If we removed the active one, fall back to the first remaining.
-    const activeName = cfg.get<string>('activeConnection');
-    if (activeName === name) {
-      const remaining = this.list();
-      await cfg.update('activeConnection', remaining[0]?.name, vscode.ConfigurationTarget.Global);
-    }
-    this._onDidChange.fire(this.active());
-  }
-}