linkshell-cli 0.5.1 → 0.5.4

package/src/runtime/bridge-session.ts

@@ -4,8 +4,9 @@ import WebSocket from "ws";
 import { hostname, platform, homedir } from "node:os";
 import { writeFileSync, readFileSync, readdirSync, statSync, unlinkSync, mkdirSync, existsSync, openSync, readSync, closeSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, basename, resolve } from "node:path";
+import { join, basename, resolve, relative, isAbsolute } from "node:path";
 import {
+  agentV2MessageRoute,
   createEnvelope,
   parseEnvelope,
   parseTypedPayload,
@@ -42,6 +43,17 @@ export interface BridgeSessionOptions {
   agentUi?: boolean;
   agentProvider?: AgentProvider;
   agentCommand?: string;
+  /**
+   * Confinement root for client-driven filesystem operations
+   * (terminal.browse / terminal.file.read / terminal.mkdir).
+   * Defaults to the bridge's cwd. Paths resolving outside this root are rejected.
+   */
+  fileRoot?: string;
+  /**
+   * Ports the tunnel proxy is allowed to connect to on 127.0.0.1.
+   * Defaults to DEFAULT_TUNNEL_PORTS when omitted.
+   */
+  allowedTunnelPorts?: number[];
 }
 
 const HEARTBEAT_INTERVAL = 15_000;
@@ -50,6 +62,16 @@ const RECONNECT_MAX_DELAY = 30_000;
 const RECONNECT_MAX_ATTEMPTS = 20;
 const DEFAULT_TERMINAL_ID = "default";
 const HOOK_BODY_LIMIT = 256 * 1024;
+const SCROLLBACK_LINES = 500;
+// Upper bound on concurrent live terminals — forceNew removed the cwd-dedup
+// ceiling, so bound growth to avoid PTY/fd exhaustion from a runaway client.
+const MAX_TERMINALS = 12;
+// How long to keep an exited terminal (with its scrollback) in memory so the
+// client can replay its final output before it is reaped.
+const EXITED_TERMINAL_GRACE_MS = 30_000;
+// Default ports the bridge will proxy tunnel requests to when no explicit
+// allowlist is configured. Covers the common dev servers the app tunnels to.
+const DEFAULT_TUNNEL_PORTS = [3000, 3001, 4321, 5173, 5174, 8080, 8000, 8081];
 const PERMISSION_REQUEST_TIMEOUT_MS = Number(
   process.env.LINKSHELL_PERMISSION_TIMEOUT_MS ?? 5 * 60_000,
 );
@@ -211,9 +233,23 @@ function hookPermissionOptions(suggestions: unknown[]): Array<{
   ];
 }
 
+function stripGatewayBase(url: URL): string {
+  url.hash = "";
+  url.search = "";
+  url.pathname = "";
+  return url.toString().replace(/\/+$/, "");
+}
+
+function isHttpGatewayUrl(url: URL): boolean {
+  return url.protocol === "http:" || url.protocol === "https:";
+}
+
 function getPairingGatewayParam(gatewayHttpUrl: string): string | undefined {
   try {
     const url = new URL(gatewayHttpUrl);
+    if (!isHttpGatewayUrl(url)) {
+      return undefined;
+    }
     const hostname = url.hostname.trim().toLowerCase();
     if (
       hostname === "localhost" ||
@@ -227,15 +263,15 @@ function getPairingGatewayParam(gatewayHttpUrl: string): string | undefined {
         return undefined; // No LAN interface found, can't help
       }
       url.hostname = lanIp;
-      return url.toString().replace(/\/+$/, "");
+      return stripGatewayBase(url);
     }
-    return url.toString().replace(/\/+$/, "");
+    return stripGatewayBase(url);
   } catch {
     return gatewayHttpUrl.replace(/\/+$/, "") || undefined;
   }
 }
 
-function resolvePairingGateway(
+export function resolvePairingGateway(
   gatewayHttpUrl: string,
   pairingGateway?: string,
 ): string | undefined {
@@ -246,24 +282,36 @@ function resolvePairingGateway(
 
   try {
     const absoluteUrl = new URL(override);
-    return absoluteUrl.toString().replace(/\/+$/, "");
+    if (isHttpGatewayUrl(absoluteUrl)) {
+      return stripGatewayBase(absoluteUrl);
+    }
   } catch {
-    try {
-      const baseUrl = new URL(gatewayHttpUrl);
-      const normalizedHost = override
-        .replace(/^https?:\/\//i, "")
-        .replace(/\/.*$/, "")
-        .trim();
-
-      if (!normalizedHost) {
-        return getPairingGatewayParam(gatewayHttpUrl);
-      }
+    // Fall through and treat the override as a host[:port] value.
+  }
 
-      baseUrl.hostname = normalizedHost;
-      return baseUrl.toString().replace(/\/+$/, "");
-    } catch {
+  try {
+    const baseUrl = new URL(gatewayHttpUrl);
+    if (!isHttpGatewayUrl(baseUrl)) {
       return override.replace(/\/+$/, "") || undefined;
     }
+    const normalizedHost = override
+      .replace(/^https?:\/\//i, "")
+      .replace(/\/.*$/, "")
+      .trim();
+
+    if (!normalizedHost) {
+      return getPairingGatewayParam(gatewayHttpUrl);
+    }
+
+    baseUrl.host = normalizedHost;
+    return stripGatewayBase(baseUrl);
+  } catch {
+    try {
+      const prefixed = new URL(`http://${override.replace(/^\/+/, "")}`);
+      return stripGatewayBase(prefixed);
+    } catch {
+      return undefined;
+    }
   }
 }
 
@@ -274,6 +322,28 @@ function normalizeAgentProvider(provider: unknown): AgentProvider {
   return "codex";
 }
 
+export function resolveAgentWorkspaceProviders(options: {
+  agentProvider?: AgentProvider;
+  agentCommand?: string;
+}): AgentProvider[] {
+  if (options.agentCommand?.trim()) {
+    return [normalizeAgentProvider(options.agentProvider ?? "custom")];
+  }
+  const defaultProviders: AgentProvider[] = ["codex", "claude"];
+  const detected = detectAvailableProviders();
+  const requested = options.agentProvider ? normalizeAgentProvider(options.agentProvider) : undefined;
+  const ordered = [
+    ...(requested ? [requested] : []),
+    ...detected,
+    ...defaultProviders,
+  ];
+  const unique: AgentProvider[] = [];
+  for (const provider of ordered) {
+    if (!unique.includes(provider)) unique.push(provider);
+  }
+  return unique;
+}
+
 export class BridgeSession {
   private readonly options: BridgeSessionOptions;
   private socket: WebSocket | undefined;
@@ -283,6 +353,7 @@ export class BridgeSession {
   private reconnectAttempts = 0;
   private reconnecting = false;
   private sessionId = "";
+  private hostToken: string | undefined;
   private exited = false;
   private stopped = false;
   private permissionStacks = new Map<string, Array<{
@@ -302,10 +373,51 @@ export class BridgeSession {
   private agentSession: AgentSessionProxy | undefined;
   private agentWorkspace: AgentWorkspaceProxy | undefined;
   private machineIdentity: MachineIdentity | undefined;
+  // Confinement root for client-driven filesystem ops; resolved once at construction.
+  private readonly fileRoot: string;
+  // Ports the tunnel proxy may connect to on 127.0.0.1.
+  private readonly allowedTunnelPorts: Set<number>;
+  // Pending deletions of exited terminals (terminalId → timer) so we can clear on stop().
+  private exitedTerminalTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  // Invoked when all terminals have exited naturally — closes embedded gateway,
+  // removes daemon PID file, etc. Set by the CLI entry point.
+  private onAllTerminalsExited: (() => void | Promise<void>) | undefined;
 
   constructor(options: BridgeSessionOptions) {
     this.options = options;
     this.sessionId = options.sessionId ?? "";
+    // Confine client-driven file ops to the user's home by default (single-user
+    // self-hosted model: the owner browses their own projects under ~). This
+    // still blocks /etc, /usr, other users' dirs. Override via --file-root.
+    this.fileRoot = resolve(options.fileRoot ?? homedir());
+    this.allowedTunnelPorts = new Set(
+      options.allowedTunnelPorts && options.allowedTunnelPorts.length > 0
+        ? options.allowedTunnelPorts
+        : DEFAULT_TUNNEL_PORTS,
+    );
+  }
+
+  /** Register a callback invoked once all terminals exit naturally (process self-cleanup). */
+  setOnAllTerminalsExited(handler: () => void | Promise<void>): void {
+    this.onAllTerminalsExited = handler;
+  }
+
+  /**
+   * Resolve a client-supplied path inside the confinement root.
+   * Returns the absolute resolved path, or null if it escapes the root.
+   */
+  private resolveConfinedPath(clientPath: string): string | null {
+    const expanded = clientPath.startsWith("~")
+      ? clientPath.replace(/^~/, homedir())
+      : clientPath;
+    // Resolve relative paths against the confinement root, not process.cwd().
+    const target = isAbsolute(expanded)
+      ? resolve(expanded)
+      : resolve(this.fileRoot, expanded);
+    const rel = relative(this.fileRoot, target);
+    if (rel === "") return target; // the root itself
+    if (rel.startsWith("..") || isAbsolute(rel)) return null;
+    return target;
   }
 
   private log(msg: string): void {
@@ -324,6 +436,9 @@ export class BridgeSession {
       `starting session (gateway=${this.options.gatewayUrl}, provider=${this.options.providerConfig.provider})`,
     );
     this.machineIdentity = loadOrCreateMachineIdentity();
+    // Sweep stale LinkShell hook entries (dead curl ports) left by a prior crash
+    // before we write fresh ones for this session.
+    this.sweepStaleHookConfigs();
     if (!this.sessionId) {
       await this.createPairing();
     }
@@ -334,9 +449,7 @@ export class BridgeSession {
     }
     if (this.options.agentUi) {
       process.env.LINKSHELL_ID = this.terminalHookMarker(DEFAULT_TERMINAL_ID);
-      const availableProviders = this.options.agentProvider
-        ? [normalizeAgentProvider(this.options.agentProvider)]
-        : detectAvailableProviders();
+      const availableProviders = resolveAgentWorkspaceProviders(this.options);
       const agentOptions = {
         sessionId: this.sessionId,
         cwd: process.cwd(),
@@ -374,9 +487,14 @@ export class BridgeSession {
     const body = (await res.json()) as {
       sessionId: string;
       pairingCode: string;
+      hostToken?: string;
       expiresAt: string;
     };
     this.sessionId = body.sessionId;
+    // Secret token proving we are the legitimate host for this session; sent on
+    // every host WS connect so a third party who learns the sessionId can't
+    // hijack the host role.
+    this.hostToken = body.hostToken;
 
     const pairingGateway = resolvePairingGateway(
       this.options.gatewayHttpUrl,
@@ -447,11 +565,24 @@ export class BridgeSession {
     url.searchParams.set("sessionId", this.sessionId);
     url.searchParams.set("role", "host");
     const authToken = await this.resolveAuthToken();
+    const wsOptions: WebSocket.ClientOptions = {};
+    const headers: Record<string, string> = {};
     if (authToken) {
+      // Prefer the Authorization header so the token doesn't leak into URLs/logs.
+      headers["Authorization"] = `Bearer ${authToken}`;
+      // TODO: remove the query param once all gateways read the Authorization
+      // header. Kept for backward compatibility with older gateways that only
+      // read the `auth_token` query parameter.
       url.searchParams.set("auth_token", authToken);
     }
+    if (this.hostToken) {
+      headers["x-linkshell-host-token"] = this.hostToken;
+    }
+    if (Object.keys(headers).length > 0) {
+      wsOptions.headers = headers;
+    }
 
-    this.socket = new WebSocket(url);
+    this.socket = new WebSocket(url, wsOptions);
 
     this.socket.on("open", () => {
       process.stderr.write(
@@ -516,6 +647,52 @@ export class BridgeSession {
 
   private async handleMessage(envelope: Envelope): Promise<void> {
     const tid = envelope.terminalId ?? DEFAULT_TERMINAL_ID;
+    const agentV2Route = agentV2MessageRoute(envelope.type);
+    if (agentV2Route === "client_write" || agentV2Route === "client_read") {
+      if (!this.agentWorkspace) {
+        this.send(
+          createEnvelope({
+            type: "agent.v2.capabilities",
+            sessionId: this.sessionId,
+            payload: {
+              enabled: false,
+              provider: normalizeAgentProvider(
+                this.options.agentProvider ?? "codex",
+              ),
+              machineId: this.machineIdentity?.machineId,
+              workspaceProtocolVersion: 2,
+              error: "Agent Workspace is not enabled. Start CLI with --agent-ui.",
+              supportsSessionList: false,
+              supportsSessionLoad: false,
+              supportsImages: false,
+              supportsAudio: false,
+              supportsPermission: false,
+              supportsPlan: false,
+              supportsCancel: false,
+            },
+          }),
+        );
+        return;
+      }
+      if (envelope.type === "agent.v2.prompt" || envelope.type === "agent.v2.command.execute") {
+        this.refreshAgentPermissionHooks();
+      }
+      try {
+        await this.agentWorkspace.handleEnvelope(envelope);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.log(`agent.v2 invalid message: ${message}`);
+        this.send(createEnvelope({
+          type: "session.error",
+          sessionId: this.sessionId,
+          payload: {
+            code: "invalid_message",
+            message: `Invalid Agent Workspace message: ${message}`,
+          },
+        }));
+      }
+      return;
+    }
     switch (envelope.type) {
       case "terminal.input": {
         const p = parseTypedPayload("terminal.input", envelope.payload);
@@ -532,10 +709,24 @@ export class BridgeSession {
       case "terminal.spawn": {
         const p = parseTypedPayload("terminal.spawn", envelope.payload);
         const normalizedCwd = resolve(p.cwd);
-        // Dedup: if a running terminal already exists for this cwd, return it
-        const existing = [...this.terminals.values()].find(
-          (t) => t.status === "running" && resolve(t.cwd) === normalizedCwd,
-        );
+        // Cap concurrent terminals — forceNew removed the cwd-dedup ceiling, so
+        // bound growth explicitly to avoid PTY/fd exhaustion from a runaway client.
+        const liveCount = [...this.terminals.values()].filter((t) => t.status === "running").length;
+        if (liveCount >= MAX_TERMINALS) {
+          this.send(createEnvelope({
+            type: "session.error",
+            sessionId: this.sessionId,
+            payload: { code: "too_many_terminals", message: `最多同时打开 ${MAX_TERMINALS} 个终端` },
+          }));
+          break;
+        }
+        // Dedup by cwd UNLESS the client explicitly asks for a fresh terminal
+        // (forceNew lets web open multiple tabs in the same directory).
+        const existing = p.forceNew
+          ? undefined
+          : [...this.terminals.values()].find(
+              (t) => t.status === "running" && resolve(t.cwd) === normalizedCwd,
+            );
         if (existing) {
           this.send(createEnvelope({
             type: "terminal.spawned",
@@ -576,9 +767,15 @@ export class BridgeSession {
       }
       case "terminal.browse": {
         const p = parseTypedPayload("terminal.browse", envelope.payload);
-        // Expand ~ to home directory
-        const rawPath = p.path.startsWith("~") ? p.path.replace(/^~/, homedir()) : p.path;
-        const browsePath = resolve(rawPath);
+        const browsePath = this.resolveConfinedPath(p.path);
+        if (browsePath === null) {
+          this.send(createEnvelope({
+            type: "terminal.browse.result",
+            sessionId: this.sessionId,
+            payload: { path: p.path, entries: [], error: "Path is outside the allowed root", requestId: p.requestId },
+          }));
+          break;
+        }
         try {
           const entries = readdirSync(browsePath, { withFileTypes: true })
             .filter((d) => !d.name.startsWith(".") && (d.isDirectory() || (p.includeFiles && d.isFile())))
@@ -613,8 +810,22 @@ export class BridgeSession {
       }
       case "terminal.file.read": {
         const p = parseTypedPayload("terminal.file.read", envelope.payload);
-        const rawPath = p.path.startsWith("~") ? p.path.replace(/^~/, homedir()) : p.path;
-        const filePath = resolve(rawPath);
+        const filePath = this.resolveConfinedPath(p.path);
+        if (filePath === null) {
+          this.send(createEnvelope({
+            type: "terminal.file.read.result",
+            sessionId: this.sessionId,
+            payload: {
+              path: p.path,
+              content: "",
+              encoding: "utf8",
+              truncated: false,
+              error: "Path is outside the allowed root",
+              requestId: p.requestId,
+            },
+          }));
+          break;
+        }
         try {
           const stats = statSync(filePath);
           if (!stats.isFile()) {
@@ -662,8 +873,15 @@ export class BridgeSession {
       }
       case "terminal.mkdir": {
         const p = parseTypedPayload("terminal.mkdir", envelope.payload);
-        const rawPath = p.path.startsWith("~") ? p.path.replace(/^~/, homedir()) : p.path;
-        const dirPath = resolve(rawPath);
+        const dirPath = this.resolveConfinedPath(p.path);
+        if (dirPath === null) {
+          this.send(createEnvelope({
+            type: "terminal.browse.result",
+            sessionId: this.sessionId,
+            payload: { path: p.path, entries: [], error: "Path is outside the allowed root" },
+          }));
+          break;
+        }
         try {
           mkdirSync(dirPath, { recursive: true });
           // Browse the parent to refresh the listing
@@ -842,44 +1060,6 @@ export class BridgeSession {
         await this.agentSession.handleEnvelope(envelope);
         break;
       }
-      case "agent.v2.capabilities.request":
-      case "agent.v2.conversation.open":
-      case "agent.v2.conversation.list":
-      case "agent.v2.prompt":
-      case "agent.v2.command.execute":
-      case "agent.v2.cancel":
-      case "agent.v2.permission.respond":
-      case "agent.v2.structured_input.respond":
-      case "agent.v2.snapshot.request": {
-        if (!this.agentWorkspace) {
-          this.send(
-            createEnvelope({
-              type: "agent.v2.capabilities",
-              sessionId: this.sessionId,
-              payload: {
-                enabled: false,
-                provider: normalizeAgentProvider(
-                  this.options.agentProvider ?? "codex",
-                ),
-                machineId: this.machineIdentity?.machineId,
-                workspaceProtocolVersion: 2,
-                error: "Agent Workspace is not enabled. Start CLI with --agent-ui.",
-                supportsSessionList: false,
-                supportsSessionLoad: false,
-                supportsImages: false,
-                supportsAudio: false,
-                supportsPermission: false,
-                supportsPlan: false,
-                supportsCancel: false,
-              },
-            }),
-          );
-          break;
-        }
-        if (envelope.type === "agent.v2.prompt" || envelope.type === "agent.v2.command.execute") this.refreshAgentPermissionHooks();
-        await this.agentWorkspace.handleEnvelope(envelope);
-        break;
-      }
       case "file.upload": {
         const p = parseTypedPayload("file.upload", envelope.payload);
         const ext = p.filename.split(".").pop() || "png";
@@ -962,6 +1142,21 @@ export class BridgeSession {
   }): void {
     const { requestId, method, url: reqUrl, headers, body, port } = payload;
 
+    // SSRF guard: only proxy to ports in the allowlist (pinned to 127.0.0.1).
+    if (!this.allowedTunnelPorts.has(port)) {
+      this.log(`rejecting tunnel request to disallowed port ${port}`);
+      if (headers.upgrade === "websocket") {
+        this.send(createEnvelope({
+          type: "tunnel.ws.close",
+          sessionId: this.sessionId,
+          payload: { requestId, code: 1008, reason: `Port ${port} is not allowed` },
+        }));
+      } else {
+        this.sendTunnelError(requestId, 403, `Port ${port} is not allowed`);
+      }
+      return;
+    }
+
     // WebSocket upgrade request
     if (headers.upgrade === "websocket") {
       this.handleTunnelWsUpgrade(requestId, port, reqUrl);
@@ -1223,7 +1418,7 @@ export class BridgeSession {
       cwd,
       projectName: basename(cwd),
       provider,
-      scrollback: new ScrollbackBuffer(1000),
+      scrollback: new ScrollbackBuffer(SCROLLBACK_LINES),
       outputSeq: 0,
       statusSeq: 0,
       status: "running",
@@ -1263,6 +1458,20 @@ export class BridgeSession {
       }));
       this.sendTerminalList();
 
+      // Reap the exited terminal (and its scrollback) after a grace period so
+      // clients can replay final output, then free the memory. Tracked so the
+      // timer can be cleared on stop().
+      const reapTimer = setTimeout(() => {
+        this.exitedTerminalTimers.delete(terminalId);
+        const t = this.terminals.get(terminalId);
+        if (t && t.status === "exited") {
+          this.terminals.delete(terminalId);
+          this.log(`reaped exited terminal ${terminalId}`);
+        }
+      }, EXITED_TERMINAL_GRACE_MS);
+      if (typeof reapTimer.unref === "function") reapTimer.unref();
+      this.exitedTerminalTimers.set(terminalId, reapTimer);
+
       // If all terminals exited, close the session
       const allExited = [...this.terminals.values()].every((t) => t.status === "exited");
       if (allExited) {
@@ -1270,6 +1479,9 @@ export class BridgeSession {
         setTimeout(() => {
           this.stopHeartbeat();
           this.socket?.close();
+          // Self-clean process-level resources (embedded gateway + PID file)
+          // since the PTYs exited naturally rather than via a signal handler.
+          void this.onAllTerminalsExited?.();
         }, 500);
         process.exitCode = exitCode ?? 0;
       }
@@ -1397,9 +1609,7 @@ export class BridgeSession {
     if (!term?.hookPort) return;
     const marker = term.hookMarker;
     const curlCmd = `curl -s --connect-timeout 1 --max-time ${Math.ceil((PERMISSION_REQUEST_TIMEOUT_MS + 30_000) / 1000)} -X POST "http://127.0.0.1:${term.hookPort}/hook?m=${marker}&lid=$LINKSHELL_ID" -H 'Content-Type: application/json' --data-binary @- || true`;
-    const providers = this.options.agentProvider
-      ? [normalizeAgentProvider(this.options.agentProvider)]
-      : detectAvailableProviders();
+    const providers = resolveAgentWorkspaceProviders(this.options);
     try {
       for (const provider of providers) {
         if (provider === "codex") {
@@ -1993,6 +2203,59 @@ export class BridgeSession {
     } catch { /* ignore parse errors */ }
   }
 
+  /**
+   * Remove ALL LinkShell hook entries (any marker) from a JSON config file.
+   * Used on startup to sweep stale entries left behind by a crashed instance,
+   * whose curl ports are now dead. Matches via isLinkShellHookEntry rather than
+   * a single marker so entries from previous runs are also cleaned.
+   */
+  private sweepLinkShellHookEntries(configPath: string): void {
+    if (!existsSync(configPath)) return;
+    try {
+      // Re-read immediately before write to minimize the window for a
+      // concurrent writer to clobber our changes.
+      const raw = JSON.parse(readFileSync(configPath, "utf8"));
+      const hooks = raw.hooks as Record<string, unknown[]> | undefined;
+      if (!hooks) return;
+
+      let changed = false;
+      for (const [eventName, entries] of Object.entries(hooks)) {
+        if (!Array.isArray(entries)) continue;
+        const filtered = entries.filter((entry) => !isLinkShellHookEntry(entry));
+        if (filtered.length !== entries.length) {
+          changed = true;
+          if (filtered.length === 0) {
+            delete hooks[eventName];
+          } else {
+            hooks[eventName] = filtered;
+          }
+        }
+      }
+
+      if (changed) {
+        if (Object.keys(hooks).length === 0) {
+          delete raw.hooks;
+        }
+        writeFileSync(configPath, JSON.stringify(raw, null, 2));
+        this.log(`swept stale LinkShell hook entries from ${configPath}`);
+      }
+    } catch { /* ignore parse errors */ }
+  }
+
+  /** Sweep stale LinkShell hook entries from known shared config files on startup. */
+  private sweepStaleHookConfigs(): void {
+    const home = homedir();
+    const candidates = [
+      join(home, ".claude", "settings.json"),
+      join(home, ".codex", "hooks.json"),
+      join(home, ".gemini", "settings.json"),
+      join(process.cwd(), "hooks.json"), // copilot (per-cwd)
+    ];
+    for (const path of candidates) {
+      this.sweepLinkShellHookEntries(path);
+    }
+  }
+
   private send(message: Envelope): void {
     if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
       return;
@@ -2154,6 +2417,11 @@ export class BridgeSession {
       ws.close(1001, "Session stopped");
     }
     this.tunnelSockets.clear();
+    // Clear pending exited-terminal reap timers.
+    for (const timer of this.exitedTerminalTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.exitedTerminalTimers.clear();
     for (const term of this.terminals.values()) {
       this.cleanupHookServer(term);
       if (term.status === "running") term.pty.kill();

package/dist/cli/src/runtime/acp/claude-sessions.d.ts

@@ -1,57 +0,0 @@
-export interface ClaudeStoredSession {
-    id: string;
-    cwd: string;
-    title?: string;
-    createdAt?: number;
-    lastModified: number;
-}
-export interface StoredAgentTimelineItem {
-    id: string;
-    conversationId: string;
-    type: "message" | "tool_call";
-    kind?: "tool_activity" | "command_execution" | "file_change";
-    itemId?: string;
-    role?: "user" | "assistant" | "system";
-    content?: Array<{
-        type: "text";
-        text: string;
-    }>;
-    text?: string;
-    toolCall?: {
-        id: string;
-        name: string;
-        input?: string;
-        output?: string;
-        createdAt?: number;
-        status: "pending" | "running" | "completed" | "failed";
-    };
-    commandExecution?: {
-        command?: string;
-        cwd?: string;
-        output?: string;
-        exitCode?: number | null;
-        status?: "pending" | "running" | "completed" | "failed";
-    };
-    fileChange?: {
-        entries: Array<{
-            path: string;
-            kind?: string;
-            added?: number;
-            removed?: number;
-        }>;
-        diff?: string;
-        summary?: string;
-        status?: "pending" | "running" | "completed" | "failed";
-    };
-    createdAt: number;
-    updatedAt?: number;
-    metadata?: Record<string, unknown>;
-}
-export declare function listClaudeStoredSessions(inputCwd: string): {
-    sessions: ClaudeStoredSession[];
-};
-export declare function loadClaudeStoredTimeline(sessionId: string, conversationId: string, options?: {
-    maxItems?: number;
-}): {
-    items: StoredAgentTimelineItem[];
-};