claws-code 0.8.0

package/extension/src/backends/vscode/vscode-backend.ts

@@ -0,0 +1,282 @@
+// extension/src/backends/vscode/vscode-backend.ts
+// Thin adapter that wraps TerminalManager + CaptureStore behind the
+// TerminalBackend interface. Owns the execWaiters WeakMap (moved from
+// ServerOptions in Commit 3). All VS Code API calls are confined to this file.
+
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import { EventEmitter } from 'events';
+import { CaptureStore } from '../../capture-store';
+import { TerminalManager } from '../../terminal-manager';
+import { stripAnsi } from '../../ansi-strip';
+import { HistoryEvent } from '../../protocol';
+import { VehicleStateName, TerminalCloseOrigin } from '../../event-schemas';
+import type {
+  TerminalBackend,
+  BackendCreateOptions,
+  BackendTerminalInfo,
+  BackendLogSlice,
+  BackendSendOptions,
+  TerminalCreatedEvent,
+  TerminalClosedEvent,
+  TerminalDataEvent,
+  TerminalReadyEvent,
+  TerminalProcessExitedEvent,
+  ForegroundProcessInfo,
+} from '../../terminal-backend';
+
+type StateChangeCallback = (id: string, from: VehicleStateName | null, to: VehicleStateName) => void;
+type ContentChangeCallback = (id: string, pid: number | null, basename: string | null) => void;
+
+const MAX_READLOG_BYTES = 512 * 1024;
+
+export interface VsCodeBackendOptions {
+  captureStore: CaptureStore;
+  terminalManager: TerminalManager;
+  logger: (msg: string) => void;
+}
+
+export class VsCodeBackend extends EventEmitter implements TerminalBackend {
+  private readonly captureStore: CaptureStore;
+  private readonly tm: TerminalManager;
+
+  /** Moved from ServerOptions — exec command waiters keyed by vscode.Terminal. */
+  readonly execWaiters = new WeakMap<vscode.Terminal, Array<(ev: HistoryEvent) => void>>();
+
+  constructor(opts: VsCodeBackendOptions) {
+    super();
+    this.captureStore = opts.captureStore;
+    this.tm = opts.terminalManager;
+  }
+
+  async start(): Promise<void> {
+    // Wire TerminalManager close callback → emit 'terminal:closed' event.
+    this.tm.setTerminalCloseCallback((id: string, _wrapped: boolean, origin: TerminalCloseOrigin) => {
+      const ev: TerminalClosedEvent = {
+        id,
+        origin: origin as TerminalClosedEvent['origin'],
+      };
+      this.emit('terminal:closed', ev);
+    });
+    // start() resolves immediately — VS Code APIs are already ready at this point.
+  }
+
+  dispose(): void {
+    this.tm.dispose();
+    this.removeAllListeners();
+  }
+
+  // ── Optional: VS Code-specific state/content callbacks (not on interface) ──
+
+  /** Delegates to TerminalManager. Called by ClawsServer to wire pub/sub vehicle events. */
+  setStateChangeCallback(cb: StateChangeCallback): void {
+    this.tm.setStateChangeCallback(cb);
+  }
+
+  /** Delegates to TerminalManager. Called by ClawsServer to wire content change events. */
+  setContentChangeCallback(cb: ContentChangeCallback): void {
+    this.tm.setContentChangeCallback(cb);
+  }
+
+  /** Snapshot of currently-tracked terminal IDs (delegates to TerminalManager). */
+  liveTerminalIds(): Set<string> {
+    return this.tm.liveTerminalIds();
+  }
+
+  // ── TerminalBackend interface ──────────────────────────────────────────────
+
+  async createTerminal(opts: BackendCreateOptions): Promise<{ id: string; logPath: string | null }> {
+    if (opts.wrapped) {
+      const corrId = opts.correlationId;
+      const { id } = this.tm.createWrapped({
+        name: opts.name,
+        cwd: opts.cwd,
+        shellPath: opts.shellPath,
+        env: opts.env,
+        correlationId: corrId,
+        // AC-1: emit terminal:ready on first pty byte, exactly once, only when corrId is set.
+        onFirstOutput: corrId
+          ? (termId: string) => {
+              const ev: TerminalReadyEvent = { id: termId, correlationId: corrId };
+              this.emit('terminal:ready', ev);
+            }
+          : undefined,
+        // AF-AC Phase 1: emit terminal:process_exited before VS Code UI teardown.
+        onProcessExit: corrId
+          ? (termId: string, code: number) => {
+              const ev: TerminalProcessExitedEvent = { id: termId, correlationId: corrId, exitCode: code };
+              this.emit('terminal:process_exited', ev);
+            }
+          : undefined,
+      });
+      const ev: TerminalCreatedEvent = { id, name: opts.name ?? `Claws ${id}`, wrapped: true, logPath: null };
+      this.emit('terminal:created', ev);
+      return { id, logPath: null };
+    }
+    const { id } = this.tm.createStandard({
+      name: opts.name,
+      cwd: opts.cwd,
+      shellPath: opts.shellPath,
+      env: opts.env,
+    });
+    const ev: TerminalCreatedEvent = { id, name: opts.name ?? `Claws ${id}`, wrapped: false, logPath: null };
+    this.emit('terminal:created', ev);
+    return { id, logPath: null };
+  }
+
+  async listTerminals(): Promise<BackendTerminalInfo[]> {
+    const descriptors = await this.tm.describeAll();
+    return descriptors.map((d) => ({
+      id: d.id,
+      name: d.name,
+      shellPid: d.ptyPid ?? d.pid ?? null,
+      wrapped: d.wrapped,
+      logPath: d.logPath ?? null,
+      status: (d.status === 'adopted' ? 'alive' : d.status === 'unknown' ? 'unknown' : 'closed') as BackendTerminalInfo['status'],
+      vehicleState: d.vehicleState,
+      pid: d.pid ?? null,
+      hasShellIntegration: d.hasShellIntegration,
+      ptyMode: d.ptyMode,
+    }));
+  }
+
+  async sendText(id: string, text: string, opts?: BackendSendOptions): Promise<void> {
+    const rec = this.tm.recordById(id);
+    if (!rec) return;
+    const newline = opts?.newline !== false;
+    const paste = opts?.paste === true;
+    if (rec.pty) {
+      rec.pty.writeInjected(text, newline, paste);
+    } else {
+      rec.terminal.sendText(text, newline);
+    }
+  }
+
+  async closeTerminal(id: string, _origin?: TerminalClosedEvent['origin']): Promise<void> {
+    const origin = (_origin ?? 'orchestrator') as TerminalCloseOrigin;
+    const rec = this.tm.recordById(id);
+    if (rec?.pty) {
+      const fgPid = rec.pty.getForegroundProcess().pid ?? rec.pty.pid;
+      if (fgPid != null) {
+        try { process.kill(fgPid, 'SIGTERM'); } catch { /* already gone */ }
+        const killTimer = setTimeout(() => {
+          try {
+            process.kill(fgPid, 0);
+            process.kill(fgPid, 'SIGKILL');
+          } catch { /* already gone */ }
+        }, 5000);
+        if (typeof killTimer.unref === 'function') killTimer.unref();
+      }
+    }
+    this.tm.close(id, origin);
+  }
+
+  async readLog(id: string, offset: number | undefined, limit: number, strip: boolean): Promise<BackendLogSlice> {
+    const rec = this.tm.recordById(id);
+    if (!rec) throw new Error(`VsCodeBackend: unknown terminal id ${id}`);
+    const effectiveLimit = Math.min(limit, MAX_READLOG_BYTES);
+
+    if (rec.wrapped && rec.pty) {
+      const slice = this.captureStore.read(id, offset, effectiveLimit, strip);
+      return {
+        bytes: slice.bytes,
+        offset: slice.offset,
+        nextOffset: slice.nextOffset,
+        totalSize: slice.totalSize,
+        truncated: slice.truncated,
+      };
+    }
+
+    if (rec.logPath && fs.existsSync(rec.logPath)) {
+      const stat = fs.statSync(rec.logPath);
+      const totalSize = stat.size;
+      const start = offset !== undefined ? offset : Math.max(0, totalSize - effectiveLimit);
+      const fd = fs.openSync(rec.logPath, 'r');
+      try {
+        const buf = Buffer.alloc(Math.min(effectiveLimit, totalSize - start));
+        fs.readSync(fd, buf, 0, buf.length, start);
+        let text = buf.toString('utf8');
+        if (strip) text = stripAnsi(text);
+        return {
+          bytes: text,
+          offset: start,
+          nextOffset: start + buf.length,
+          totalSize,
+          truncated: buf.length < effectiveLimit,
+        };
+      } finally {
+        fs.closeSync(fd);
+      }
+    }
+
+    throw new Error(`VsCodeBackend: terminal ${id} is not wrapped and has no logPath`);
+  }
+
+  async getForegroundProcess(id: string): Promise<ForegroundProcessInfo> {
+    const rec = this.tm.recordById(id);
+    if (!rec?.pty) return { pid: null, basename: null };
+    return rec.pty.getForegroundProcess();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event: 'terminal:created',        listener: (ev: TerminalCreatedEvent)       => void): this;
+  on(event: 'terminal:closed',         listener: (ev: TerminalClosedEvent)        => void): this;
+  on(event: 'terminal:data',           listener: (ev: TerminalDataEvent)          => void): this;
+  /** AC-1: first pty byte for a wrapped terminal created with correlationId. */
+  on(event: 'terminal:ready',          listener: (ev: TerminalReadyEvent)         => void): this;
+  /** AF-AC Phase 1: pty process exited, fires before VS Code UI teardown. */
+  on(event: 'terminal:process_exited', listener: (ev: TerminalProcessExitedEvent) => void): this;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event: string, listener: (...args: any[]) => void): this {
+    return super.on(event, listener);
+  }
+
+  off(event: string, listener: (...args: unknown[]) => void): this {
+    return super.off(event, listener);
+  }
+
+  async focusTerminal(id: string): Promise<void> {
+    const t = this.tm.terminalById(id);
+    if (t) t.show(true);
+  }
+
+  async execCommand(id: string, command: string, timeoutMs: number): Promise<{ output: string; exitCode: number | null }> {
+    const rec = this.tm.recordById(id);
+    if (!rec) throw new Error(`VsCodeBackend: unknown terminal id ${id}`);
+
+    if (!rec.terminal.shellIntegration) {
+      // Fallback: send the command, no output capture.
+      if (rec.pty) {
+        rec.pty.writeInjected(command, true, false);
+      } else {
+        rec.terminal.sendText(command, true);
+      }
+      return { output: '', exitCode: null };
+    }
+
+    const event = await new Promise<HistoryEvent>((resolve, reject) => {
+      const list = this.execWaiters.get(rec.terminal) ?? [];
+      const resolver = (ev: HistoryEvent) => { clearTimeout(timer); resolve(ev); };
+      const timer = setTimeout(() => {
+        const i = list.indexOf(resolver);
+        if (i >= 0) list.splice(i, 1);
+        reject(new Error(`exec timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      list.push(resolver);
+      this.execWaiters.set(rec.terminal, list);
+      try {
+        rec.terminal.shellIntegration!.executeCommand(command);
+      } catch (err) {
+        clearTimeout(timer);
+        const i = list.indexOf(resolver);
+        if (i >= 0) list.splice(i, 1);
+        reject(err);
+      }
+    });
+
+    return {
+      output: '',
+      exitCode: (event as unknown as { exitCode?: number }).exitCode ?? null,
+    };
+  }
+}

package/extension/src/capture-store.ts

@@ -0,0 +1,125 @@
+import { stripAnsi } from './ansi-strip';
+
+export interface CaptureSlice {
+  bytes: string;
+  offset: number;
+  nextOffset: number;
+  totalSize: number;
+  truncated: boolean;
+}
+
+// Per-terminal bookkeeping. `buf` is a single growable Buffer whose first
+// `length` bytes are live; anything past `length` is uninitialised capacity.
+// `droppedBefore` counts bytes that have been trimmed off the front of the
+// stream but still contribute to the absolute byte offset exposed to callers.
+interface Entry {
+  buf: Buffer;
+  length: number;
+  droppedBefore: number;
+}
+
+const MIN_INITIAL_CAPACITY = 8 * 1024; // 8 KB — tiny writes stay cheap.
+
+export type CaptureAppendCallback = (id: string, chunkBytes: number) => void;
+
+export class CaptureStore {
+  private entries = new Map<string, Entry>();
+  private maxBytesPerTerminal: number;
+  // LH-9: optional sink that fires on every append. Used by ClawsServer to
+  // refresh per-worker activity timestamps for the TTL watchdog. Single
+  // callback (no list) — server is the only legitimate consumer.
+  private onAppend: CaptureAppendCallback | null = null;
+
+  constructor(maxBytesPerTerminal: number) {
+    this.maxBytesPerTerminal = maxBytesPerTerminal;
+  }
+
+  /** LH-9: Wire an activity sink. Cleared by passing null. */
+  setOnAppend(cb: CaptureAppendCallback | null): void {
+    this.onAppend = cb;
+  }
+
+  append(id: string, chunk: string | Buffer): void {
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8');
+    // Fire activity sink BEFORE the buffer mutation — cheap and cannot throw
+    // (callback-side errors are swallowed) so we never lose activity signal
+    // due to a mid-append exception. Zero-byte writes still count as a tick.
+    try { this.onAppend?.(id, data.length); } catch { /* sink errors must not break capture */ }
+    let entry = this.entries.get(id);
+    if (!entry) {
+      const initialCap = Math.max(MIN_INITIAL_CAPACITY, Math.min(data.length * 2, this.maxBytesPerTerminal));
+      entry = { buf: Buffer.allocUnsafe(Math.max(initialCap, data.length)), length: 0, droppedBefore: 0 };
+      this.entries.set(id, entry);
+    }
+    const needed = entry.length + data.length;
+    if (needed > entry.buf.length) {
+      // Grow to at least `needed`, capped at (maxBytes * 2) — the "+1 chunk"
+      // slack lets one pre-trim append happen without rebuilding twice. We
+      // allocate slightly oversized so common-case small writes don't churn.
+      const cap = Math.max(
+        needed,
+        Math.min(entry.buf.length * 2, this.maxBytesPerTerminal * 2),
+      );
+      const bigger = Buffer.allocUnsafe(cap);
+      entry.buf.copy(bigger, 0, 0, entry.length);
+      entry.buf = bigger;
+    }
+    data.copy(entry.buf, entry.length);
+    entry.length += data.length;
+    this.trim(id);
+  }
+
+  private trim(id: string): void {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    if (entry.length <= this.maxBytesPerTerminal) return;
+    const overflow = entry.length - this.maxBytesPerTerminal;
+    // Shift live window left by `overflow` bytes. Keep capacity unchanged —
+    // no allocations, no GC pressure.
+    entry.buf.copy(entry.buf, 0, overflow, entry.length);
+    entry.length -= overflow;
+    entry.droppedBefore += overflow;
+  }
+
+  read(id: string, offset: number | undefined, limit: number, strip: boolean): CaptureSlice {
+    const entry = this.entries.get(id);
+    if (!entry) {
+      return { bytes: '', offset: 0, nextOffset: 0, totalSize: 0, truncated: false };
+    }
+    const totalSize = entry.droppedBefore + entry.length;
+    const effectiveOffset = offset == null
+      ? Math.max(entry.droppedBefore, totalSize - limit)
+      : Math.max(offset, entry.droppedBefore);
+    const startInPresent = effectiveOffset - entry.droppedBefore;
+    const endInPresent = Math.min(entry.length, startInPresent + limit);
+    const sliceLength = Math.max(0, endInPresent - startInPresent);
+    // subarray returns a view into the same underlying ArrayBuffer — zero-copy
+    // until we call toString(), which only allocates for the actual slice.
+    const view = entry.buf.subarray(startInPresent, startInPresent + sliceLength);
+    const text = strip ? stripAnsi(view.toString('utf8')) : view.toString('utf8');
+    return {
+      bytes: text,
+      offset: effectiveOffset,
+      nextOffset: effectiveOffset + sliceLength,
+      totalSize,
+      truncated: totalSize > effectiveOffset + sliceLength,
+    };
+  }
+
+  clear(id: string): void {
+    this.entries.delete(id);
+  }
+
+  has(id: string): boolean {
+    return this.entries.has(id);
+  }
+
+  setMaxBytesPerTerminal(bytes: number): void {
+    this.maxBytesPerTerminal = bytes;
+    for (const id of this.entries.keys()) this.trim(id);
+  }
+
+  getMaxBytesPerTerminal(): number {
+    return this.maxBytesPerTerminal;
+  }
+}