jeo-code 0.8.43 → 0.9.0

package/src/agent/job-registry.ts

@@ -5,12 +5,14 @@
  * can keep working and later list / tail / await / cancel it via the `job` control
  * tool while stdout/stderr drain into a bounded buffer in the background.
  *
- * Lifecycle is bounded to the turn that created the registry — `cancelAll()` on
- * turn teardown guarantees no background process leaks into the next turn.
+ * Lifecycle is owned by the launch session — jobs survive turn boundaries and remain
+ * controllable across prompts; `cancelAll()` on session teardown prevents leaks.
+ *
+ * `cancelAll()` is also safe for explicit Ctrl-C cleanup.
+ *
  */
 
 export type JobStatus = "running" | "exited" | "killed" | "failed";
-export type MonitorCategory = "log" | "poll" | "watch" | "other";
 
 export interface JobRecord {
   /** Stable id, e.g. "job-1". */
@@ -21,49 +23,21 @@ export interface JobRecord {
   startedAt: number;
   finishedAt?: number;
   exitCode?: number | null;
-  /** Monitor classification; ordinary background jobs use "other". */
-  category: MonitorCategory;
-  /** Human-readable monitor purpose; ordinary jobs use their command. */
-  description: string;
-  /** Whether this monitor remains active after its first stdout line. */
-  persistent: boolean;
-}
-
-export interface MonitorStartOptions {
-  category: MonitorCategory;
-  description: string;
-  persistent?: boolean;
-  /** Public monitor timeout in seconds. */
-  timeout?: number;
-}
-
-export type MonitorJobEvent =
-  | { type: "start"; record: JobRecord }
-  | { type: "line"; record: JobRecord; line: string }
-  | { type: "done"; record: JobRecord };
-
-interface MonitorState {
-  lineBuffer: string;
-  deliveredLine: boolean;
 }
 
 interface Entry {
   record: JobRecord;
-  proc?: Bun.Subprocess<"ignore", "pipe", "pipe">;
+  proc: Bun.Subprocess<"ignore", "pipe", "pipe">;
   promise: Promise<void>;
-  monitor?: MonitorState;
-  timeout?: ReturnType<typeof setTimeout>;
 }
 
 const OUTPUT_CAP = 20000;
 const TRUNCATION_MARKER = "[…output truncated…]\n";
-const MONITOR_LINE_CAP = 4_000;
 
 export class JobRegistry {
   private readonly entries = new Map<string, Entry>();
   private readonly buffers = new Map<string, string>();
   private readonly truncated = new Set<string>();
-  private readonly monitorListeners = new Set<(event: MonitorJobEvent) => void>();
   private seq = 0;
 
   private append(id: string, chunk: string): void {
@@ -79,183 +53,58 @@ export class JobRegistry {
     this.buffers.set(id, buf);
   }
 
-  private snapshot(record: JobRecord): JobRecord {
-    return Object.freeze({ ...record });
-  }
-
-  private emit(event: MonitorJobEvent): void {
-    for (const listener of this.monitorListeners) {
-      try {
-        listener(event);
-      } catch {
-        // Monitor observers are advisory and must not affect process lifecycle.
-      }
-    }
-  }
-
-  private emitMonitor(type: MonitorJobEvent["type"], record: JobRecord, line?: string): void {
-    const snapshot = this.snapshot(record);
-    if (type === "line") this.emit({ type, record: snapshot, line: line! });
-    else this.emit({ type, record: snapshot });
-  }
-
-  /**
-   * Subscribe to monitor lifecycle events. The returned function removes this
-   * listener; exceptions thrown by listeners are ignored.
-   */
-  subscribeMonitor(listener: (event: MonitorJobEvent) => void): () => void {
-    this.monitorListeners.add(listener);
-    return () => this.monitorListeners.delete(listener);
-  }
-
-  private boundedMonitorLine(line: string): string {
-    const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
-    return normalized.length > MONITOR_LINE_CAP
-      ? `${normalized.slice(0, MONITOR_LINE_CAP - 1)}…`
-      : normalized;
-  }
-
-  private deliverStdout(id: string, chunk: string, flush = false): void {
-    const entry = this.entries.get(id);
-    if (!entry?.monitor || entry.record.status !== "running") return;
-
-    entry.monitor.lineBuffer += chunk;
-    let newline = entry.monitor.lineBuffer.indexOf("\n");
-    while (newline !== -1) {
-      const line = this.boundedMonitorLine(entry.monitor.lineBuffer.slice(0, newline));
-      entry.monitor.lineBuffer = entry.monitor.lineBuffer.slice(newline + 1);
-      if (!entry.monitor.deliveredLine || entry.record.persistent) {
-        entry.monitor.deliveredLine = true;
-        this.emitMonitor("line", entry.record, line);
-        if (!entry.record.persistent) {
-          this.cancel([id]);
-          return;
-        }
-      }
-      newline = entry.monitor.lineBuffer.indexOf("\n");
-    }
-
-    if (flush && entry.monitor.lineBuffer) {
-      const line = this.boundedMonitorLine(entry.monitor.lineBuffer);
-      entry.monitor.lineBuffer = "";
-      if (!entry.monitor.deliveredLine || entry.record.persistent) {
-        entry.monitor.deliveredLine = true;
-        this.emitMonitor("line", entry.record, line);
-        if (!entry.record.persistent) this.cancel([id]);
-      }
-      return;
-    }
-
-    // A command that never terminates a line must not grow registry memory forever.
-    if (entry.monitor.lineBuffer.length > OUTPUT_CAP) {
-      entry.monitor.lineBuffer = entry.monitor.lineBuffer.slice(-OUTPUT_CAP);
-    }
-  }
-
-  private spawn(record: JobRecord, monitor = false, timeoutSeconds?: number): JobRecord {
-    this.buffers.set(record.id, "");
+  /** Spawn and START a background OS process; returns the (running) record immediately. */
+  start(command: string, cwd: string): JobRecord {
+    this.seq += 1;
+    const id = `job-${this.seq}`;
+    const record: JobRecord = {
+      id,
+      command,
+      cwd,
+      status: "running",
+      startedAt: Date.now(),
+    };
+    this.buffers.set(id, "");
 
     let proc: Bun.Subprocess<"ignore", "pipe", "pipe">;
     try {
-      proc = Bun.spawn(["bash", "-c", record.command], {
-        cwd: record.cwd,
-        stdin: "ignore",
-        stdout: "pipe",
-        stderr: "pipe",
-      });
+      proc = Bun.spawn(["bash", "-c", command], { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
     } catch (err) {
       record.status = "failed";
       record.finishedAt = Date.now();
-      this.append(record.id, err instanceof Error ? err.message : String(err));
-      this.entries.set(record.id, { record, promise: Promise.resolve(), monitor: monitor ? { lineBuffer: "", deliveredLine: false } : undefined });
-      if (monitor) {
-        this.emitMonitor("start", record);
-        this.emitMonitor("done", record);
-      }
+      this.append(id, err instanceof Error ? err.message : String(err));
+      // No process handle to store — nothing further to drain or cancel.
+      this.entries.set(id, { record, proc: undefined as any, promise: Promise.resolve() });
       return record;
     }
 
-    const drain = async (stream: ReadableStream<Uint8Array>, stdout: boolean) => {
+    const drain = async (stream: ReadableStream<Uint8Array>) => {
       const decoder = new TextDecoder();
       for await (const chunk of stream) {
-        const text = decoder.decode(chunk, { stream: true });
-        this.append(record.id, text);
-        if (stdout) this.deliverStdout(record.id, text);
+        this.append(id, decoder.decode(chunk, { stream: true }));
       }
-      const final = decoder.decode();
-      this.append(record.id, final);
-      if (stdout) this.deliverStdout(record.id, final, true);
-    };
-
-    const entry: Entry = {
-      record,
-      proc,
-      promise: Promise.resolve(),
-      monitor: monitor ? { lineBuffer: "", deliveredLine: false } : undefined,
     };
-    this.entries.set(record.id, entry);
 
-    entry.promise = (async () => {
+    const promise = (async () => {
       try {
-        await Promise.all([drain(proc.stdout, true), drain(proc.stderr, false)]);
+        await Promise.all([drain(proc.stdout), drain(proc.stderr)]);
         const exitCode = await proc.exited;
-        if (record.status !== "killed") {
-          record.status = "exited";
-          record.exitCode = exitCode;
-        }
+        if (record.status === "killed") return;
+        record.status = "exited";
+        record.exitCode = exitCode;
       } catch (err) {
-        if (record.status !== "killed") {
-          record.status = "failed";
-          this.append(record.id, err instanceof Error ? err.message : String(err));
-        }
+        if (record.status === "killed") return;
+        record.status = "failed";
+        this.append(id, err instanceof Error ? err.message : String(err));
       } finally {
-        if (entry.timeout !== undefined) clearTimeout(entry.timeout);
         if (record.finishedAt === undefined) record.finishedAt = Date.now();
-        if (monitor) this.emitMonitor("done", record);
       }
     })();
 
-    if (monitor) {
-      if (timeoutSeconds !== undefined) {
-        const timeout = setTimeout(() => this.cancel([record.id]), timeoutSeconds * 1000);
-        timeout.unref?.();
-        entry.timeout = timeout;
-      }
-      this.emitMonitor("start", record);
-    }
+    this.entries.set(id, { record, proc, promise });
     return record;
   }
 
-  /** Spawn and START a background OS process; returns the (running) record immediately. */
-  start(command: string, cwd: string): JobRecord {
-    this.seq += 1;
-    return this.spawn({
-      id: `job-${this.seq}`,
-      command,
-      cwd,
-      status: "running",
-      startedAt: Date.now(),
-      category: "other",
-      description: command,
-      persistent: false,
-    });
-  }
-
-  /** Start a monitor using the same bounded process and output lifecycle as `start()`. */
-  startMonitor(command: string, cwd: string, options: MonitorStartOptions): JobRecord {
-    this.seq += 1;
-    return this.spawn({
-      id: `job-${this.seq}`,
-      command,
-      cwd,
-      status: "running",
-      startedAt: Date.now(),
-      category: options.category,
-      description: options.description,
-      persistent: options.persistent ?? false,
-    }, true, options.timeout);
-  }
-
   list(): JobRecord[] {
     return [...this.entries.values()].map(e => e.record);
   }
@@ -303,10 +152,6 @@ export class JobRegistry {
       if (e.record.status === "running") {
         e.record.status = "killed";
         e.record.finishedAt = Date.now();
-        if (e.timeout !== undefined) {
-          clearTimeout(e.timeout);
-          e.timeout = undefined;
-        }
         e.proc?.kill();
       }
       out.push(e.record);
@@ -314,7 +159,7 @@ export class JobRegistry {
     return out;
   }
 
-  /** Kill every still-running job (turn teardown / Ctrl-C). */
+  /** Kill every still-running job (session teardown / Ctrl-C). */
   cancelAll(): JobRecord[] {
     return this.cancel(this.running().map(r => r.id));
   }

package/src/agent/job-tool.ts

@@ -55,7 +55,7 @@ export function createJobTool(registry: JobRegistry): ToolHandler {
     if (action === "list") {
       const rows = registry.list();
       if (rows.length === 0) {
-        return { success: true, output: `No background jobs this turn. Launch one with job {action:"start", command}.` };
+        return { success: true, output: `No background jobs in this session. Launch one with job {action:"start", command}.` };
       }
       const running = rows.filter(r => r.status === "running").length;
       return { success: true, output: `${rows.length} job(s), ${running} running:\n${rows.map(rowLine).join("\n")}` };
@@ -89,7 +89,7 @@ export function createJobTool(registry: JobRegistry): ToolHandler {
       const head = stillRunning > 0
         ? `Awaited ${recs.length} job(s); ${stillRunning} still running after the ${timeoutMs}ms timeout — await again or cancel.`
         : `Awaited ${recs.length} job(s); all settled.`;
-      return { success: true, output: `${head}\n\n${recs.map(rowLine).join("\n")}` };
+      return { success: stillRunning === 0, output: `${head}\n\n${recs.map(rowLine).join("\n")}` };
     }
 
     if (action === "cancel") {

package/src/agent/lsp-rename-tool.ts

@@ -29,7 +29,7 @@ function err(message: string): ToolResult {
 const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 
 export function createLspRenameTool(): ToolHandler {
-  return async (args: Record<string, any>, cwd: string, _onProgress, signal): Promise<ToolResult> => {
+  return async (args: Record<string, any>, cwd: string): Promise<ToolResult> => {
     const fileArg = typeof args.file === "string" ? args.file.trim() : "";
     if (!fileArg) return err(`lsp_rename requires a non-empty "file".`);
 
@@ -95,7 +95,7 @@ export function createLspRenameTool(): ToolHandler {
         for (const span of [...spans].sort((a, b) => b.start - a.start)) {
           newText = newText.slice(0, span.start) + newName + newText.slice(span.start + span.length);
         }
-        const res = await writeTool(rel, newText, cwd, signal);
+        const res = await writeTool(rel, newText, cwd);
         if (!res.success) return err(`${rel}: ${res.error ?? "write failed"}`);
       }
     }

package/src/agent/monitor-registry.ts

@@ -0,0 +1,233 @@
+/**
+ * In-process registry for line-oriented background monitor commands.
+ *
+ * Monitors are real background OS processes, but unlike jobs they surface each
+ * stdout/stderr line immediately through `onLine`. A non-persistent monitor is
+ * intentionally one-shot: its process is killed after the first emitted line.
+ * The launch session owns each registry; monitors survive turn boundaries until
+ * `cancelAll()` is called during explicit session teardown.
+ */
+
+export type MonitorStatus = "running" | "exited" | "killed" | "failed";
+
+export interface MonitorRecord {
+  /** Stable id, e.g. `monitor-1`. */
+  id: string;
+  command: string;
+  cwd: string;
+  status: MonitorStatus;
+  startedAt: number;
+  finishedAt?: number;
+  exitCode?: number | null;
+  /** Persistent monitors continue after the first output line. */
+  persistent: boolean;
+}
+
+export type MonitorLineHandler = (record: MonitorRecord, line: string) => void | Promise<void>;
+
+export interface MonitorRegistryOptions {
+  /** Called once for every complete stdout/stderr line. */
+  onLine?: MonitorLineHandler;
+}
+
+interface Entry {
+  record: MonitorRecord;
+  proc?: Bun.Subprocess<"ignore", "pipe", "pipe">;
+  promise: Promise<void>;
+}
+
+const OUTPUT_CAP = 20_000;
+const TRUNCATION_MARKER = "[…output truncated…]\n";
+
+export class MonitorRegistry {
+  private readonly entries = new Map<string, Entry>();
+  private readonly buffers = new Map<string, string>();
+  private readonly truncated = new Set<string>();
+  private readonly onLine?: MonitorLineHandler;
+  private seq = 0;
+  constructor(options: MonitorRegistryOptions | MonitorLineHandler = {}) {
+    this.onLine = typeof options === "function" ? options : options.onLine;
+  }
+
+  private append(id: string, chunk: string): void {
+    if (!chunk) return;
+    let buf = (this.buffers.get(id) ?? "") + chunk;
+    if (buf.length > OUTPUT_CAP) {
+      buf = buf.slice(buf.length - OUTPUT_CAP);
+      if (!this.truncated.has(id)) {
+        this.truncated.add(id);
+        buf = TRUNCATION_MARKER + buf;
+      }
+    }
+    this.buffers.set(id, buf);
+  }
+
+  private async emit(record: MonitorRecord, line: string): Promise<void> {
+    try {
+      await this.onLine?.(record, line);
+    } catch {
+      // A UI/event sink must never turn a monitor's settled process into an
+      // unhandled rejection. The monitor output remains available through tail.
+    }
+  }
+
+  private stopAfterFirstLine(entry: Entry): void {
+    if (entry.record.status !== "running") return;
+    entry.record.status = "killed";
+    entry.record.finishedAt = Date.now();
+    try {
+      entry.proc?.kill();
+    } catch {
+      // The process may have exited between the line event and kill().
+    }
+  }
+
+  private async drain(entry: Entry, stream: ReadableStream<Uint8Array>): Promise<void> {
+    const decoder = new TextDecoder();
+    let pending = "";
+    try {
+      for await (const chunk of stream) {
+        const text = decoder.decode(chunk, { stream: true });
+        this.append(entry.record.id, text);
+        pending += text;
+        while (true) {
+          const match = pending.match(/(?:\r\n|\n|\r)/);
+          if (!match || match.index === undefined) break;
+          const line = pending.slice(0, match.index);
+          pending = pending.slice(match.index + match[0].length);
+          if (entry.record.status !== "running") return;
+          await this.emit(entry.record, line);
+          if (!entry.record.persistent) {
+            this.stopAfterFirstLine(entry);
+            return;
+          }
+        }
+      }
+      const tail = decoder.decode();
+      if (tail) {
+        this.append(entry.record.id, tail);
+        pending += tail;
+      }
+      if (pending.length > 0 && entry.record.status === "running") {
+        await this.emit(entry.record, pending);
+        if (!entry.record.persistent) this.stopAfterFirstLine(entry);
+      }
+    } catch {
+      // SIGTERM commonly closes a Bun stream with an iteration error. Cancellation
+      // is a normal terminal path, not a rejected monitor promise.
+    }
+  }
+
+  /** Spawn and start a monitor; returns its running record immediately. */
+  start(command: string, cwd: string, persistentOrOptions: boolean | { persistent?: boolean } = false): MonitorRecord {
+    this.seq += 1;
+    const id = `monitor-${this.seq}`;
+    const persistent = typeof persistentOrOptions === "boolean"
+      ? persistentOrOptions
+      : persistentOrOptions.persistent === true;
+    const record: MonitorRecord = {
+      id,
+      command,
+      cwd,
+      status: "running",
+      startedAt: Date.now(),
+      persistent,
+    };
+    this.buffers.set(id, "");
+
+    let proc: Bun.Subprocess<"ignore", "pipe", "pipe">;
+    try {
+      proc = Bun.spawn(["bash", "-c", command], { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+    } catch (err) {
+      record.status = "failed";
+      record.finishedAt = Date.now();
+      this.append(id, err instanceof Error ? err.message : String(err));
+      const failed: Entry = { record, promise: Promise.resolve() };
+      this.entries.set(id, failed);
+      return record;
+    }
+
+    const entry = { record, proc, promise: Promise.resolve() } as Entry;
+    this.entries.set(id, entry);
+    entry.promise = (async () => {
+      try {
+        await Promise.all([this.drain(entry, proc.stdout), this.drain(entry, proc.stderr)]);
+        const exitCode = await proc.exited;
+        if (record.status === "killed") return;
+        record.status = "exited";
+        record.exitCode = exitCode;
+      } catch (err) {
+        if (record.status === "killed") return;
+        record.status = "failed";
+        this.append(id, err instanceof Error ? err.message : String(err));
+      } finally {
+        if (record.finishedAt === undefined) record.finishedAt = Date.now();
+      }
+    })();
+    // Keep the promise observed even when callers only use list/tail; all paths
+    // above handle process and stream errors so this never becomes unhandled.
+    void entry.promise.catch(() => undefined);
+    return record;
+  }
+
+  list(): MonitorRecord[] {
+    return [...this.entries.values()].map(e => e.record);
+  }
+
+  get(id: string): MonitorRecord | undefined {
+    return this.entries.get(id)?.record;
+  }
+
+  running(): MonitorRecord[] {
+    return this.list().filter(r => r.status === "running");
+  }
+
+  /** Current buffered stdout/stderr for one monitor. */
+  tail(id: string): string {
+    return this.buffers.get(id) ?? "";
+  }
+
+  /** Wait for the given ids. A positive timeout leaves unfinished records running. */
+  async awaitIds(ids: string[], timeoutMs?: number): Promise<MonitorRecord[]> {
+    const targets = ids
+      .map(id => this.entries.get(id))
+      .filter((entry): entry is Entry => entry !== undefined);
+    const all = Promise.all(targets.map(entry => entry.promise)).then(() => undefined);
+    if (timeoutMs !== undefined && timeoutMs > 0) {
+      let handle: ReturnType<typeof setTimeout> | undefined;
+      const timer = new Promise<void>(resolve => {
+        handle = setTimeout(resolve, timeoutMs);
+      });
+      await Promise.race([all, timer]);
+      clearTimeout(handle);
+    } else {
+      await all;
+    }
+    return targets.map(entry => entry.record);
+  }
+
+  /** Kill the given monitors. Already-terminal records are returned unchanged. */
+  cancel(ids: string[]): MonitorRecord[] {
+    const out: MonitorRecord[] = [];
+    for (const id of ids) {
+      const entry = this.entries.get(id);
+      if (!entry) continue;
+      if (entry.record.status === "running") {
+        entry.record.status = "killed";
+        entry.record.finishedAt = Date.now();
+        try {
+          entry.proc?.kill();
+        } catch {
+          // Process exited concurrently; the terminal state is already correct.
+        }
+      }
+      out.push(entry.record);
+    }
+    return out;
+  }
+
+  /** Kill every monitor still running at session teardown / Ctrl-C. */
+  cancelAll(): MonitorRecord[] {
+    return this.cancel(this.running().map(record => record.id));
+  }
+}