@standardagents/code 0.0.2-dev.517db40 → 0.0.2-dev.b3cdaaf

package/src/process-registry.ts

@@ -0,0 +1,122 @@
+/**
+ * Registry of long-running background processes the agent spawns.
+ *
+ * The metadata lives in the THREAD's durable key-value store (server-side), not
+ * on this client — so the process list resumes from any machine, at any time,
+ * and nothing about it is kept on the client. (The process *output* logs are the
+ * one host-local thing: a detached process writes its stdout to a file on the
+ * machine it runs on; that file can only live there.)
+ *
+ * Liveness is re-derived from the OS for this machine's processes — a recorded
+ * "running" entry is verified with a signal-0 probe — so the registry self-heals
+ * if a process died while we weren't watching. Processes on other machines show
+ * their last-known status (we can't probe a PID we don't own).
+ */
+import path from "node:path";
+import os from "node:os";
+import type { ApiClient } from "./api.ts";
+
+/** Process *output* logs are host-local (the process writes its stdout here). */
+export const LOG_DIR = path.join(os.homedir(), ".standardagents", "process-logs");
+
+/** The thread KV key under which the process list is stored. */
+const KEY = "bg_processes";
+
+export type ProcessStatus = "running" | "exited" | "stopped";
+
+export interface ProcessEntry {
+  id: string;
+  pid: number;
+  command: string;
+  description?: string;
+  cwd: string;
+  machine: string;
+  logPath: string;
+  startedAt: number;
+  status: ProcessStatus;
+  exitCode?: number | null;
+  endedAt?: number;
+}
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM means the process exists but isn't ours; ESRCH means it's gone.
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+export class ProcessRegistry {
+  constructor(
+    private api: ApiClient,
+    private threadId: string,
+    private machine: string
+  ) {}
+
+  private async read(): Promise<ProcessEntry[]> {
+    const value = await this.api.kvGet(this.threadId, KEY);
+    return Array.isArray(value) ? (value as ProcessEntry[]) : [];
+  }
+
+  private async write(entries: ProcessEntry[]): Promise<void> {
+    await this.api.kvSet(this.threadId, KEY, entries);
+  }
+
+  /** Mark this machine's dead "running" entries as exited. Returns true if any changed. */
+  private reconcileLiveness(entries: ProcessEntry[]): boolean {
+    let changed = false;
+    for (const e of entries) {
+      if (e.machine === this.machine && e.status === "running" && !isAlive(e.pid)) {
+        e.status = "exited";
+        e.endedAt = Date.now();
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
+  /** All tracked processes, newest first, with liveness re-checked + persisted. */
+  async list(): Promise<ProcessEntry[]> {
+    const entries = await this.read();
+    if (this.reconcileLiveness(entries)) await this.write(entries);
+    return entries.sort((a, b) => b.startedAt - a.startedAt);
+  }
+
+  async runningCount(): Promise<number> {
+    const entries = await this.list();
+    return entries.filter((e) => e.status === "running").length;
+  }
+
+  async get(id: string): Promise<ProcessEntry | null> {
+    return (await this.read()).find((e) => e.id === id) ?? null;
+  }
+
+  async add(entry: ProcessEntry): Promise<void> {
+    const entries = await this.read();
+    entries.push(entry);
+    await this.write(entries);
+  }
+
+  async markExited(id: string, exitCode: number | null): Promise<void> {
+    const entries = await this.read();
+    const e = entries.find((x) => x.id === id);
+    if (e && e.status === "running") {
+      e.status = "exited";
+      e.exitCode = exitCode;
+      e.endedAt = Date.now();
+      await this.write(entries);
+    }
+  }
+
+  async markStopped(id: string): Promise<void> {
+    const entries = await this.read();
+    const e = entries.find((x) => x.id === id);
+    if (e) {
+      e.status = "stopped";
+      e.endedAt = Date.now();
+      await this.write(entries);
+    }
+  }
+}

package/src/stream.ts

@@ -0,0 +1,134 @@
+/**
+ * Subscribes to a thread's message WebSocket to render streamed assistant text
+ * and detect end-of-turn (an assistant message with non-empty text content,
+ * which under stopOnResponse means the agent has finished its turn).
+ */
+import type { ApiClient } from "./api.ts";
+
+export interface StreamHooks {
+  onChunk(text: string): void;
+  /**
+   * A complete assistant message. `hasToolCalls` is true for narration that
+   * precedes tool calls (the turn continues) and false for the final answer
+   * (the turn is over).
+   */
+  onAssistantText(content: string, hasToolCalls: boolean): void;
+  /**
+   * A custom thread event (the `{ type: "event", eventType, data }` channel) —
+   * e.g. `tool_call_started`, `tool_call_done`, `generation`.
+   */
+  onEvent?(eventType: string, data: any): void;
+  onError(err: string): void;
+}
+
+export class MessageStream {
+  private ws: WebSocket | null = null;
+  private closed = false;
+  private reconnectAttempt = 0;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private resolveConnected: (() => void) | null = null;
+
+  constructor(
+    private api: ApiClient,
+    private threadId: string,
+    private hooks: StreamHooks
+  ) {}
+
+  /**
+   * Connect and stay connected. Resolves on first open; reconnects on any drop
+   * with exponential backoff. Silent — the bridge surfaces the user-facing
+   * connection status; completion is detected via HTTP polling regardless, so a
+   * dropped stream only affects live display, not correctness.
+   */
+  connect(): Promise<void> {
+    return new Promise((resolve) => {
+      let settled = false;
+      this.resolveConnected = () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      setTimeout(() => this.resolveConnected?.(), 8000);
+      this.openSocket();
+    });
+  }
+
+  private openSocket(): void {
+    if (this.closed) return;
+    const url = `${this.api.wsEndpoint}/api/threads/${this.threadId}/stream?token=${encodeURIComponent(this.api.bearer)}`;
+    let ws: WebSocket;
+    try {
+      ws = new WebSocket(url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      this.reconnectAttempt = 0;
+      this.resolveConnected?.();
+    });
+    ws.addEventListener("message", (ev) => this.onMessage(String((ev as MessageEvent).data)));
+    // Both 'error' (failed open) and 'close' must drive reconnection.
+    ws.addEventListener("error", () => this.handleDrop(ws));
+    ws.addEventListener("close", () => this.handleDrop(ws));
+  }
+
+  private handleDrop(ws: WebSocket): void {
+    if (this.ws !== ws) return;
+    this.ws = null;
+    this.scheduleReconnect();
+  }
+
+  private scheduleReconnect(): void {
+    if (this.closed || this.reconnectTimer) return;
+    this.reconnectAttempt++;
+    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15000);
+    const delay = base + Math.floor(Math.random() * 400);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.openSocket();
+    }, delay);
+  }
+
+  close(): void {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+  }
+
+  private onMessage(raw: string): void {
+    let msg: any;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "event" && typeof msg.eventType === "string") {
+      this.hooks.onEvent?.(msg.eventType, msg.data);
+      return;
+    }
+    if (msg.type === "message_chunk" && (msg.depth ?? 0) === 0) {
+      if (typeof msg.chunk === "string") this.hooks.onChunk(msg.chunk);
+      return;
+    }
+    if (msg.type === "message_data" && (msg.depth ?? 0) === 0) {
+      const data = msg.data || {};
+      if (data.role === "assistant" && typeof data.content === "string" && data.content.trim()) {
+        // tool_calls is serialized as a JSON string, not an array.
+        const tc = data.tool_calls;
+        const hasToolCalls = Array.isArray(tc)
+          ? tc.length > 0
+          : typeof tc === "string" && tc.trim() !== "" && tc.trim() !== "null" && tc.trim() !== "[]";
+        this.hooks.onAssistantText(data.content, hasToolCalls);
+      }
+      if (data.role === "assistant" && data.status === "failed" && data.error) {
+        this.hooks.onError(String(data.error));
+      }
+    }
+  }
+}