agent-yes 1.73.2 → 1.74.0

package/ts/cli.ts

@@ -16,6 +16,17 @@ import { buildRustArgs } from "./buildRustArgs.ts";
   }
 }
 
+// Subcommand fast path: `cy ls / read / cat / tail / head / send` bypass the
+// agent-spawn machinery (and the --rust dispatch) and operate on the global
+// pid index instead. Must run before checkAndAutoUpdate / yargs / Rust spawn.
+{
+  const { isSubcommand, runSubcommand } = await import("./subcommands.ts");
+  if (isSubcommand(process.argv[2])) {
+    const code = await runSubcommand(process.argv);
+    process.exit(code ?? 0);
+  }
+}
+
 // Check for updates before starting — installs & re-execs if a newer version exists.
 // Fast path: cached result (no network), so this adds near-zero latency most of the time.
 await checkAndAutoUpdate();

package/ts/globalPidIndex.spec.ts

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir, homedir } from "os";
+import path from "path";
+
+// homedir() is what the module derives `~/.agent-yes/pids.jsonl` from.
+// Stub it to a fresh tempdir per test so we don't touch the user's real
+// global index file.
+let testHome: string;
+
+vi.mock("os", async () => {
+  const actual = await vi.importActual<typeof import("os")>("os");
+  return {
+    ...actual,
+    homedir: () => testHome,
+  };
+});
+
+beforeEach(async () => {
+  testHome = await mkdtemp(path.join(tmpdir(), "agent-yes-test-"));
+  // Reset module cache so the import below picks up the new home.
+  vi.resetModules();
+});
+
+afterEach(async () => {
+  await rm(testHome, { recursive: true, force: true }).catch(() => null);
+});
+
+async function loadModule() {
+  return await import("./globalPidIndex.ts");
+}
+
+describe("globalPidIndex", () => {
+  it("appends a record and reads it back with last-line-wins merge", async () => {
+    const mod = await loadModule();
+    await mod.appendGlobalPid({
+      pid: 11111,
+      cli: "claude",
+      prompt: "hello",
+      cwd: "/tmp/x",
+      log_file: "/tmp/x/.agent-yes/11111.raw.log",
+      fifo_file: "/tmp/x/.agent-yes/fifo/11111.stdin",
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: 1000,
+    });
+
+    const records = await mod.readGlobalPids();
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({
+      pid: 11111,
+      cli: "claude",
+      status: "active",
+    });
+  });
+
+  it("merges multiple appends for the same pid (last write wins)", async () => {
+    const mod = await loadModule();
+    await mod.appendGlobalPid({
+      pid: 22222,
+      cli: "codex",
+      prompt: null,
+      cwd: "/a",
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: 1,
+    });
+    await mod.updateGlobalPidStatus(22222, {
+      status: "exited",
+      exit_code: 0,
+      exit_reason: "completed",
+    });
+
+    const records = await mod.readGlobalPids();
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({
+      pid: 22222,
+      status: "exited",
+      exit_code: 0,
+      exit_reason: "completed",
+    });
+  });
+
+  it("liveOnly filter drops records with status=exited even if pid is alive", async () => {
+    const mod = await loadModule();
+    // Use this very process's pid — guaranteed alive.
+    const livePid = process.pid;
+    await mod.appendGlobalPid({
+      pid: livePid,
+      cli: "claude",
+      prompt: null,
+      cwd: "/a",
+      log_file: null,
+      status: "exited",
+      exit_code: 0,
+      exit_reason: null,
+      started_at: 1,
+    });
+    const live = await mod.readGlobalPids({ liveOnly: true });
+    expect(live).toHaveLength(0);
+    const all = await mod.readGlobalPids();
+    expect(all).toHaveLength(1);
+  });
+
+  it("liveOnly filter drops dead pids", async () => {
+    const mod = await loadModule();
+    // PID 999999 is virtually never live in CI.
+    await mod.appendGlobalPid({
+      pid: 999999,
+      cli: "claude",
+      prompt: null,
+      cwd: "/a",
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: 1,
+    });
+    const live = await mod.readGlobalPids({ liveOnly: true });
+    expect(live).toHaveLength(0);
+  });
+
+  it("getGlobalPidIndexPath returns a stable path under homedir", async () => {
+    const mod = await loadModule();
+    const p = mod.getGlobalPidIndexPath();
+    expect(p).toBe(path.join(testHome, ".agent-yes", "pids.jsonl"));
+  });
+
+  it("readGlobalPids returns [] when the file does not exist", async () => {
+    const mod = await loadModule();
+    const records = await mod.readGlobalPids();
+    expect(records).toEqual([]);
+  });
+
+  it("updateGlobalPidStatus is a no-op for unknown pids", async () => {
+    const mod = await loadModule();
+    await mod.updateGlobalPidStatus(7777, { status: "exited" });
+    const records = await mod.readGlobalPids();
+    expect(records).toEqual([]);
+  });
+
+  it("skips corrupt lines without throwing", async () => {
+    const mod = await loadModule();
+    await mod.appendGlobalPid({
+      pid: 5555,
+      cli: "claude",
+      prompt: null,
+      cwd: "/a",
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: 1,
+    });
+    // Inject a corrupt line directly.
+    const { appendFile } = await import("fs/promises");
+    await appendFile(mod.getGlobalPidIndexPath(), "not-json-at-all\n");
+
+    const records = await mod.readGlobalPids();
+    expect(records).toHaveLength(1);
+    expect(records[0]?.pid).toBe(5555);
+  });
+});

package/ts/globalPidIndex.ts

@@ -0,0 +1,143 @@
+import { appendFile, mkdir, readFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { lock } from "proper-lockfile";
+import { logger } from "./logger.ts";
+
+/**
+ * Global, cross-runtime pid registry at `~/.agent-yes/pids.jsonl`.
+ *
+ * Schema mirrors Rust's `PidRecord` exactly (snake_case) so the Rust binary
+ * and the TS implementation can both read and write the same file. Rust
+ * uses serde's default (deny-unknown = false), so TS-only extras like
+ * `fifo_file` are silently dropped on Rust rewrites — fine, we re-add
+ * them on the next TS status update.
+ *
+ * Wire format (one JSON object per line, JSONL):
+ *
+ *   {"pid":1234,"cli":"claude","prompt":null,"cwd":"/foo",
+ *    "log_file":"/foo/.agent-yes/1234.raw.log",
+ *    "fifo_file":"/foo/.agent-yes/fifo/1234.stdin",
+ *    "status":"active","exit_code":null,"exit_reason":null,
+ *    "started_at":1735689600000}
+ *
+ * Append semantics (TS) + rewrite-on-update (Rust) coexist because the
+ * reader always merges by `pid`, last-line wins.
+ */
+
+export interface GlobalPidRecord {
+  pid: number;
+  cli: string;
+  prompt: string | null;
+  cwd: string;
+  log_file: string | null;
+  fifo_file?: string | null;
+  status: "active" | "idle" | "exited";
+  exit_code: number | null;
+  exit_reason: string | null;
+  started_at: number;
+}
+
+const GLOBAL_DIR = path.join(homedir(), ".agent-yes");
+const GLOBAL_FILE = path.join(GLOBAL_DIR, "pids.jsonl");
+
+export function getGlobalPidIndexPath(): string {
+  return GLOBAL_FILE;
+}
+
+async function ensureDir() {
+  await mkdir(GLOBAL_DIR, { recursive: true });
+}
+
+async function withLock<R>(fn: () => Promise<R>): Promise<R> {
+  await ensureDir();
+  let release: (() => Promise<void>) | undefined;
+  try {
+    release = await lock(GLOBAL_DIR, {
+      lockfilePath: GLOBAL_FILE + ".lock",
+      retries: { retries: 5, minTimeout: 50, maxTimeout: 500 },
+    });
+    return await fn();
+  } finally {
+    await release?.();
+  }
+}
+
+/** Append one full record line. Caller must provide all required fields. */
+export async function appendGlobalPid(record: GlobalPidRecord): Promise<void> {
+  try {
+    await withLock(async () => {
+      await appendFile(GLOBAL_FILE, JSON.stringify(record) + "\n");
+    });
+  } catch (error) {
+    logger.debug("[globalPidIndex] append failed:", error);
+  }
+}
+
+/** Append a partial status update by pid (status, exit_code, exit_reason). */
+export async function updateGlobalPidStatus(
+  pid: number,
+  patch: Partial<Pick<GlobalPidRecord, "status" | "exit_code" | "exit_reason">>,
+): Promise<void> {
+  try {
+    await withLock(async () => {
+      const current = await readGlobalPidsRaw();
+      const existing = current.find((r) => r.pid === pid);
+      if (!existing) return; // unknown pid — nothing to update
+      const merged: GlobalPidRecord = { ...existing, ...patch };
+      await appendFile(GLOBAL_FILE, JSON.stringify(merged) + "\n");
+    });
+  } catch (error) {
+    logger.debug("[globalPidIndex] updateStatus failed:", error);
+  }
+}
+
+/**
+ * Read the file once without merge logic — internal helper for status updates.
+ */
+async function readGlobalPidsRaw(): Promise<GlobalPidRecord[]> {
+  let raw: string;
+  try {
+    raw = await readFile(GLOBAL_FILE, "utf-8");
+  } catch (err: any) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const merged = new Map<number, GlobalPidRecord>();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const doc = JSON.parse(trimmed) as GlobalPidRecord;
+      if (typeof doc.pid !== "number") continue;
+      const prev = merged.get(doc.pid);
+      merged.set(doc.pid, prev ? { ...prev, ...doc } : doc);
+    } catch {
+      // skip corrupt
+    }
+  }
+  return Array.from(merged.values());
+}
+
+/**
+ * Read all records, last-line-per-pid wins (events get merged).
+ * Optionally filter to live processes only.
+ */
+export async function readGlobalPids(
+  opts: {
+    liveOnly?: boolean;
+  } = {},
+): Promise<GlobalPidRecord[]> {
+  const records = await readGlobalPidsRaw();
+  if (!opts.liveOnly) return records;
+  return records.filter((r) => r.status !== "exited" && isProcessAlive(r.pid));
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/ts/pidStore.ts

@@ -2,6 +2,7 @@ import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import { logger } from "./logger.ts";
 import { JsonlStore } from "./JsonlStore.ts";
+import { appendGlobalPid, updateGlobalPidStatus } from "./globalPidIndex.ts";
 
 export interface PidRecord {
   _id?: string;
@@ -85,6 +86,22 @@ export class PidStore {
     }
 
     logger.debug(`[pidStore] Registered process ${pid}`);
+
+    // Mirror to the cross-runtime global index (~/.agent-yes/pids.jsonl).
+    // Fire-and-forget — failures must not block agent startup.
+    appendGlobalPid({
+      pid,
+      cli,
+      prompt: prompt ?? null,
+      cwd,
+      log_file: logFile,
+      fifo_file: fifoFile,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: now,
+    }).catch(() => null);
+
     return result;
   }
 
@@ -102,6 +119,13 @@ export class PidStore {
 
     await this.store.updateById(existing._id!, patch);
     logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
+
+    // Mirror to global index. Same fire-and-forget policy.
+    updateGlobalPidStatus(pid, {
+      status,
+      exit_code: extra?.exitCode ?? null,
+      exit_reason: extra?.exitReason ?? null,
+    }).catch(() => null);
   }
 
   getAllRecords(): PidRecord[] {