codehost 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+# [0.17.0](https://github.com/snomiao/codehost/compare/v0.16.0...v0.17.0) (2026-06-11)
+
+
+### Bug Fixes
+
+* **vscode:** reject the desktop bin/code wrapper — probe serve-web support, not just --version ([e5b133d](https://github.com/snomiao/codehost/commit/e5b133d0ff38f4e1052f87c22279c7850eb98968))
+
+
+### Features
+
+* **history:** durable history via hostId + machine-preferring deep-link resolution ([1935579](https://github.com/snomiao/codehost/commit/1935579a40fb7c42f46b8f1596497dac812cdc2b))
+* **host:** one daemon per host — `dev` registers with a live root daemon instead of spawning a second peer ([43051de](https://github.com/snomiao/codehost/commit/43051deaae33f647b26bdcf0facb0bac9507471f))
+* **identity:** stable per-machine hostId, advertised in PeerMeta; web groups workspaces by host ([43a48a2](https://github.com/snomiao/codehost/commit/43a48a2630534c36c399f0cce294a2e96235b5fb))
+* **lib:** embeddable room-client bundle for external consoles (agent-yes.com) ([fd0afd1](https://github.com/snomiao/codehost/commit/fd0afd19234816127b640c397eeac5cc7968f484))
+* **plugins:** daemon plugin layer + agent-yes plugin (agents[] in meta, ay API proxy over the tunnel) ([60f77b2](https://github.com/snomiao/codehost/commit/60f77b2dbbe3b649bbc8a34982b028d5a432ddb7))
+* **tree:** root daemons advertise enumerated workspaces; live meta updates; exact deep-link matching ([81493be](https://github.com/snomiao/codehost/commit/81493be6694d85110a0e9f1244bd6604875c02a2))
+
+# [0.16.0](https://github.com/snomiao/codehost/compare/v0.15.0...v0.16.0) (2026-06-10)
+
+
+### Features
+
+* **provision:** codehost init scaffolds .codehost/ (config + setup hooks) ([b1a2e9c](https://github.com/snomiao/codehost/commit/b1a2e9c23230e09dc6a291dbcab098083bb59f4d))
+* **provision:** daemon-side provision handler over the tunnel ([c297e95](https://github.com/snomiao/codehost/commit/c297e9577b3e1a65260ab105478feb63186fce46))
+* **provision:** tested security core for workspace provisioning ([ca7508c](https://github.com/snomiao/codehost/commit/ca7508c48e78eb46fbf8bf42ef398360bea38f86))
+* **web:** provisioning browser flow — run setup.sh on repo open, stream log ([9bd8742](https://github.com/snomiao/codehost/commit/9bd8742b143e84d386f8af138df73e57cac70e46))
+
 # [0.15.0](https://github.com/snomiao/codehost/compare/v0.14.0...v0.15.0) (2026-06-10)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -18,6 +18,7 @@
     "dev:signal": "cd worker && wrangler dev",
     "cli": "bun src/cli/index.ts",
     "build": "vite build && vite build --config vite.sw.config.ts",
+    "build:lib": "bun build src/web/room-client.ts --target browser --format esm --minify --outfile dist/room-client.js",
     "deploy:signal": "cd worker && wrangler deploy",
     "deploy:pages": "vite build && wrangler pages deploy dist/public --project-name codehost",
     "start": "bun src/server.ts",
@@ -38,6 +39,7 @@
     "oxmgr": "^0.4.0",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
+    "yaml": "^2.9.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {

package/src/cli/commands/dev.ts

@@ -3,12 +3,14 @@ import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { ensureHostId } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { announceConnect } from "../open-url";
 import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
 import { repoIdentity } from "../git";
-import { toPosixPath } from "../../shared/repo";
+import { liveDaemon, registerWorkspace } from "../registry";
+import { shareableDeepLink, toPosixPath } from "../../shared/repo";
 import { DEFAULT_SIGNAL_URL } from "./serve";
 
 interface DevArgs {
@@ -17,6 +19,7 @@ interface DevArgs {
   name?: string;
   signal: string;
   daemon: boolean;
+  standalone: boolean;
   port?: number;
 }
 
@@ -52,6 +55,11 @@ export const devCommand: CommandModule<{}, DevArgs> = {
         type: "boolean",
         default: false,
       })
+      .option("standalone", {
+        describe: "Always spawn an own peer + VS Code, even when a host daemon already runs",
+        type: "boolean",
+        default: false,
+      })
       .option("port", {
         describe: "Fixed port for the local VS Code server (default: ephemeral)",
         type: "number",
@@ -68,6 +76,28 @@ export const devCommand: CommandModule<{}, DevArgs> = {
     const dir = resolve(process.cwd(), argv.dir);
     const host = hostname();
 
+    // One daemon per host: a single VS Code serve-web opens any local path via
+    // ?folder=, so when a root daemon already runs here, just REGISTER this
+    // directory with it (it re-advertises within moments) instead of spawning a
+    // second peer + VS Code. --standalone restores the old behavior.
+    const daemon = argv.standalone ? null : liveDaemon();
+    if (daemon) {
+      registerWorkspace(dir);
+      const id = repoIdentity(dir);
+      const path =
+        (id.repo
+          ? shareableDeepLink({ repo: id.repo, branch: id.branch })
+          : shareableDeepLink({ folder: toPosixPath(dir), host })) ?? "/";
+      console.log(`[codehost] host daemon already serving "${daemon.root}" (pid ${daemon.pid})`);
+      console.log(`[codehost] registered ${dir} with it — no second daemon needed`);
+      console.log(`[codehost] open: https://codehost.dev${path}#t=${encodeURIComponent(daemon.token)}`);
+      if (daemon.token !== argv.token) {
+        console.log("[codehost] note: the host daemon's room differs from your -t; the link above uses the daemon's room");
+      }
+      console.log("[codehost] (use --standalone to force an own daemon instead)");
+      return;
+    }
+
     if (argv.daemon) {
       const { ok } = await launchServeDaemon({
         command: "dev",
@@ -90,6 +120,7 @@ export const devCommand: CommandModule<{}, DevArgs> = {
       // the real OS path for the local VS Code working dir.
       cwd: toPosixPath(dir),
       host,
+      hostId: ensureHostId(),
       kind: "repo",
       repo: id.repo,
       branch: id.branch,

package/src/cli/commands/expose.ts

@@ -2,6 +2,7 @@ import { hostname } from "node:os";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { ensureHostId } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { runServer } from "../run-server";
 import { DEFAULT_SIGNAL_URL } from "./serve";
@@ -78,6 +79,7 @@ export const exposeCommand: CommandModule<{}, ExposeArgs> = {
       name: argv.name ?? `localhost:${argv.port}`,
       cwd: `localhost:${argv.port}`,
       host,
+      hostId: ensureHostId(),
     };
 
     // No VS Code: tunnel directly to the given port, stripping the /vs/<peerId>

package/src/cli/commands/init.ts

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+import type { CommandModule } from "yargs";
+import { scaffoldCodehost } from "../init";
+
+interface InitArgs {
+  dir: string;
+  force: boolean;
+}
+
+export const initCommand: CommandModule<{}, InitArgs> = {
+  command: "init [dir]",
+  describe: "Scaffold .codehost/ (config.yaml + setup.sh) so repo links auto-provision",
+  builder: (y) =>
+    y
+      .positional("dir", { describe: "Home dir to scaffold (defaults to cwd)", type: "string", default: "." })
+      .option("force", { alias: "f", describe: "Overwrite existing files", type: "boolean", default: false }) as any,
+  handler: (argv) => {
+    const dir = resolve(process.cwd(), argv.dir);
+    const written = scaffoldCodehost(dir, argv.force);
+    if (written.length === 0) {
+      console.log(`[codehost] .codehost/ already set up in ${dir} (use --force to overwrite)`);
+      return;
+    }
+    console.log(`[codehost] scaffolded:\n${written.map((p) => `  ${p}`).join("\n")}`);
+    console.log(`[codehost] edit .codehost/setup.sh, then run: codehost serve ${dir}`);
+  },
+};

package/src/cli/commands/serve.ts

@@ -2,12 +2,24 @@ import { hostname } from "node:os";
 import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
-import { DEFAULT_LAYOUT, toPosixPath } from "../../shared/repo";
+import { DEFAULT_LAYOUT, GITHUB_HOST, toPosixPath } from "../../shared/repo";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { ensureHostId } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { announceConnect } from "../open-url";
+import { agentYesPlugin } from "../plugins/agent-yes";
+import { withPluginMeta } from "../plugins/types";
+import { readCodehostConfig } from "../provision-server";
+import {
+  clearDaemonPresence,
+  readRegisteredWorkspaces,
+  workspacesFile,
+  writeDaemonPresence,
+} from "../registry";
+import { repoIdentity } from "../git";
 import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
+import { enumerateWorkspaces } from "../workspaces";
 
 export const DEFAULT_SIGNAL_URL = "wss://signal.codehost.dev";
 
@@ -84,23 +96,56 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     }
 
     // A workspace root: repos under it open by GitHub-shaped deep link, mapped
-    // onto subfolders via VS Code's ?folder= using this layout.
-    const meta: PeerMeta = {
-      name: argv.name ?? host,
-      // VS Code-web ?folder= form for the browser (C:\ws -> /C:/ws); the real
-      // OS path `dir` is still what we spawn VS Code in.
-      cwd: toPosixPath(dir),
-      host,
-      kind: "root",
-      layout: DEFAULT_LAYOUT,
+    // onto subfolders via VS Code's ?folder= using this layout. The layout is
+    // the same template provisioning uses (.codehost/config.yaml `workspace`),
+    // so the advertised list and the provisioned paths agree.
+    const layout = readCodehostConfig(dir).workspace || DEFAULT_LAYOUT;
+    const plugins = [agentYesPlugin()].filter((p) => p != null);
+    const buildMeta = (): PeerMeta => {
+      // Layout-enumerated checkouts plus directories other `codehost dev` runs
+      // registered with this host daemon (git-identified best-effort).
+      const workspaces = enumerateWorkspaces(dir, layout);
+      for (const w of readRegisteredWorkspaces()) {
+        const path = toPosixPath(w.path);
+        if (workspaces.some((x) => x.path === path)) continue;
+        const id = repoIdentity(w.path);
+        workspaces.push({
+          path,
+          ...(id.repo ? { repo: id.repo } : {}),
+          ...(id.branch ? { branch: id.branch } : {}),
+        });
+      }
+      return withPluginMeta(
+        {
+          name: argv.name ?? host,
+          // VS Code-web ?folder= form for the browser (C:\ws -> /C:/ws); the
+          // real OS path `dir` is still what we spawn VS Code in.
+          cwd: toPosixPath(dir),
+          host,
+          hostId: ensureHostId(),
+          kind: "root",
+          layout,
+          workspaces,
+        },
+        plugins,
+      );
     };
 
+    // Mark this process as the host daemon, so later `codehost dev` runs
+    // register their directory with it instead of spawning a second peer.
+    writeDaemonPresence({ pid: process.pid, root: dir, token: argv.token, startedAt: Date.now() });
+    process.on("exit", () => clearDaemonPresence());
+
     announceConnect(argv.token);
     await runServer({
       token: argv.token,
       signal: argv.signal,
-      meta,
+      meta: buildMeta(),
+      refreshMeta: buildMeta,
+      watchFiles: [workspacesFile()],
+      plugins,
       label: `serving workspace root ${dir}`,
+      provision: { homeDir: dir, host: GITHUB_HOST },
       launch: async (basePath) => {
         const v = await launchVscode({ dir, basePath, port: argv.port });
         return { port: v.port, stop: v.stop };

package/src/cli/config.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ensureHostId, readConfig, writeConfig } from "./config";
+
+const tmpConfig = () => join(mkdtempSync(join(tmpdir(), "codehost-config-")), "config.json");
+
+describe("ensureHostId", () => {
+  test("mints a UUID once and returns the same id on later calls", () => {
+    const file = tmpConfig();
+    const first = ensureHostId(file);
+    expect(first).toMatch(/^[0-9a-f-]{36}$/);
+    expect(ensureHostId(file)).toBe(first);
+    expect(readConfig(file).hostId).toBe(first);
+  });
+
+  test("preserves other config fields when minting", () => {
+    const file = tmpConfig();
+    writeConfig({ token: "Str0ng-Token-99" }, file);
+    const id = ensureHostId(file);
+    const config = JSON.parse(readFileSync(file, "utf8"));
+    expect(config).toEqual({ token: "Str0ng-Token-99", hostId: id });
+  });
+
+  test("returns an existing hostId without rewriting", () => {
+    const file = tmpConfig();
+    writeConfig({ hostId: "pre-existing-id" }, file);
+    expect(ensureHostId(file)).toBe("pre-existing-id");
+  });
+});

package/src/cli/config.ts

@@ -3,25 +3,38 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
 // Persistent CLI config under ~/.codehost (same root as the managed VS Code
-// cache in vscode-install.ts). Currently just the reusable room token so
-// `codehost setup` lands on a stable room URL across runs.
+// cache in vscode-install.ts): the reusable room token and this machine's
+// stable hostId.
 
 const CONFIG_FILE = join(homedir(), ".codehost", "config.json");
 
 export interface CliConfig {
   /** Room token reused by `setup` until --new-token or an explicit -t. */
   token?: string;
+  /** Stable machine identity (UUID), minted once on first use. Every daemon on
+   *  this machine advertises it, so the web UI can group peers by host and
+   *  history entries survive daemon restarts (peerIds are per-process). */
+  hostId?: string;
 }
 
-export function readConfig(): CliConfig {
+export function readConfig(file: string = CONFIG_FILE): CliConfig {
   try {
-    return JSON.parse(readFileSync(CONFIG_FILE, "utf8")) as CliConfig;
+    return JSON.parse(readFileSync(file, "utf8")) as CliConfig;
   } catch {
     return {};
   }
 }
 
-export function writeConfig(config: CliConfig): void {
-  mkdirSync(dirname(CONFIG_FILE), { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+export function writeConfig(config: CliConfig, file: string = CONFIG_FILE): void {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(config, null, 2));
+}
+
+/** This machine's persistent hostId, minting + saving it on first call. */
+export function ensureHostId(file: string = CONFIG_FILE): string {
+  const config = readConfig(file);
+  if (config.hostId) return config.hostId;
+  const hostId = crypto.randomUUID();
+  writeConfig({ ...config, hostId }, file);
+  return hostId;
 }

package/src/cli/daemonize.ts

@@ -75,6 +75,10 @@ function buildForegroundArgv(opts: ServeDaemonOptions): string[] {
   const parts = [process.execPath, process.argv[1], opts.command ?? "serve", opts.arg ?? opts.dir, "-t", opts.token, "--signal", opts.signal];
   if (opts.name) parts.push("--name", opts.name);
   if (opts.port) parts.push("--port", String(opts.port));
+  // An oxmgr-managed `dev` must stay a real daemon across restarts/reboots —
+  // never collapse into register-with-the-host-daemon-and-exit (oxmgr would
+  // see an instant exit and thrash).
+  if ((opts.command ?? "serve") === "dev") parts.push("--standalone");
   return parts;
 }
 

package/src/cli/index.ts

@@ -2,6 +2,7 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { setupCommand } from "./commands/setup";
+import { initCommand } from "./commands/init";
 import { serveCommand } from "./commands/serve";
 import { devCommand } from "./commands/dev";
 import { exposeCommand } from "./commands/expose";
@@ -14,6 +15,7 @@ yargs(hideBin(process.argv))
   .scriptName("codehost")
   .usage("$0 <command> [options]")
   .command(setupCommand)
+  .command(initCommand)
   .command(serveCommand)
   .command(devCommand)
   .command(exposeCommand)

package/src/cli/init.test.ts

@@ -0,0 +1,48 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { scaffoldCodehost } from "./init";
+
+const homes: string[] = [];
+afterAll(() => homes.forEach((h) => rmSync(h, { recursive: true, force: true })));
+function mkHome(): string {
+  const h = mkdtempSync(join(tmpdir(), "codehost-init-"));
+  homes.push(h);
+  return h;
+}
+
+describe("scaffoldCodehost", () => {
+  test("writes config.yaml + setup.sh + setup.ps1", () => {
+    const home = mkHome();
+    const written = scaffoldCodehost(home);
+    expect(written).toHaveLength(3);
+    expect(existsSync(join(home, ".codehost", "config.yaml"))).toBe(true);
+    expect(existsSync(join(home, ".codehost", "setup.sh"))).toBe(true);
+    expect(existsSync(join(home, ".codehost", "setup.ps1"))).toBe(true);
+  });
+
+  test("config.yaml is valid YAML with a workspace template", () => {
+    const home = mkHome();
+    scaffoldCodehost(home);
+    const cfg = parseYaml(readFileSync(join(home, ".codehost", "config.yaml"), "utf8"));
+    expect(cfg.workspace).toBe("ws/{owner}/{repo}/tree/{branch}");
+  });
+
+  test("setup.sh keeps shell vars literal (no JS interpolation leaked)", () => {
+    const home = mkHome();
+    scaffoldCodehost(home);
+    const sh = readFileSync(join(home, ".codehost", "setup.sh"), "utf8");
+    expect(sh).toContain("$CODEHOST_WS");
+    expect(sh).toContain("${ws%/tree/$CODEHOST_BRANCH}");
+    expect(sh).toContain("git -C \"$repo\" worktree add");
+  });
+
+  test("idempotent: a second run writes nothing; --force overwrites", () => {
+    const home = mkHome();
+    expect(scaffoldCodehost(home)).toHaveLength(3);
+    expect(scaffoldCodehost(home)).toHaveLength(0);
+    expect(scaffoldCodehost(home, true)).toHaveLength(3);
+  });
+});

package/src/cli/init.ts

@@ -0,0 +1,103 @@
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Scaffolds a home's `.codehost/` config dir: an editable, idempotent setup hook
+// (run on every repo open) plus a config.yaml. Provisioning is opt-in by these
+// files existing — `codehost init` is how you opt in.
+
+const CONFIG_YAML = `# codehost workspace config — see docs/provisioning.md
+
+# Where /gh/<owner>/<repo>/tree/<branch> lands, relative to this home dir.
+# Default (if omitted): {owner}/{repo}/tree/{branch}
+workspace: "ws/{owner}/{repo}/tree/{branch}"
+
+# Optional: only these repos may auto-provision (a trailing /* is an owner
+# wildcard). Empty/absent = allow all. The room token already grants access, so
+# this is extra hardening, not the primary gate.
+# allowlist:
+#   - github.com/snomiao/*
+`;
+
+const SETUP_SH = `#!/usr/bin/env bash
+# codehost provisioning hook. Runs on every open of /gh/<owner>/<repo>/tree/<branch>
+# BEFORE the editor opens CODEHOST_WS. Keep it idempotent: clone/worktree if
+# missing, fast-skip if present. Edit freely (install deps, pull/rebase policy…).
+#
+# Env in:  CODEHOST_OWNER  CODEHOST_REPO  CODEHOST_BRANCH  CODEHOST_HOST
+#          CODEHOST_HOME (this dir)       CODEHOST_WS (the path the editor opens)
+set -euo pipefail
+
+ws="$CODEHOST_WS"
+if [ -e "$ws/.git" ]; then
+  echo "[setup] $ws already provisioned"
+  exit 0
+fi
+
+# Primary clone = the workspace path minus the /tree/<branch> tail (layout-agnostic).
+repo="\${ws%/tree/$CODEHOST_BRANCH}"
+url="https://$CODEHOST_HOST/$CODEHOST_OWNER/$CODEHOST_REPO.git"
+
+if [ ! -e "$repo/.git" ]; then
+  echo "[setup] cloning $url"
+  mkdir -p "$(dirname "$repo")"
+  git clone "$url" "$repo"
+fi
+
+echo "[setup] adding worktree $ws @ $CODEHOST_BRANCH"
+mkdir -p "$(dirname "$ws")"
+git -C "$repo" fetch --quiet origin "$CODEHOST_BRANCH" || true
+git -C "$repo" worktree add "$ws" "$CODEHOST_BRANCH" \\
+  || git -C "$repo" worktree add -b "$CODEHOST_BRANCH" "$ws" "origin/$CODEHOST_BRANCH"
+
+# Example: install deps for this worktree (uncomment / edit).
+# ( cd "$ws" && bun install )
+
+echo "[setup] ready: $ws"
+`;
+
+const SETUP_PS1 = `# codehost provisioning hook (Windows). See setup.sh for the contract.
+$ErrorActionPreference = "Stop"
+$ws = $env:CODEHOST_WS
+if (Test-Path (Join-Path $ws ".git")) { Write-Host "[setup] $ws already provisioned"; exit 0 }
+
+$repo = $ws -replace "[\\\\/]tree[\\\\/]$([regex]::Escape($env:CODEHOST_BRANCH))$", ""
+$url = "https://$($env:CODEHOST_HOST)/$($env:CODEHOST_OWNER)/$($env:CODEHOST_REPO).git"
+
+if (-not (Test-Path (Join-Path $repo ".git"))) {
+  Write-Host "[setup] cloning $url"
+  New-Item -ItemType Directory -Force -Path (Split-Path $repo) | Out-Null
+  git clone $url $repo
+}
+Write-Host "[setup] adding worktree $ws @ $($env:CODEHOST_BRANCH)"
+New-Item -ItemType Directory -Force -Path (Split-Path $ws) | Out-Null
+git -C $repo worktree add $ws $env:CODEHOST_BRANCH
+Write-Host "[setup] ready: $ws"
+`;
+
+const FILES: Array<{ rel: string; body: string; exec?: boolean }> = [
+  { rel: "config.yaml", body: CONFIG_YAML },
+  { rel: "setup.sh", body: SETUP_SH, exec: true },
+  { rel: "setup.ps1", body: SETUP_PS1 },
+];
+
+/** Write `<homeDir>/.codehost/{config.yaml,setup.sh,setup.ps1}`. Existing files
+ *  are kept unless `force`. Returns the list of files actually written. */
+export function scaffoldCodehost(homeDir: string, force = false): string[] {
+  const dir = join(homeDir, ".codehost");
+  mkdirSync(dir, { recursive: true });
+  const written: string[] = [];
+  for (const f of FILES) {
+    const path = join(dir, f.rel);
+    if (existsSync(path) && !force) continue;
+    writeFileSync(path, f.body);
+    if (f.exec) {
+      try {
+        chmodSync(path, 0o755);
+      } catch {
+        // non-POSIX fs — ignore
+      }
+    }
+    written.push(path);
+  }
+  return written;
+}

package/src/cli/plugins/agent-yes.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { agentYesPlugin, readAgents } from "./agent-yes";
+import { routePlugins, withPluginMeta } from "./types";
+
+function makeAyDir(lines: object[]): string {
+  const dir = mkdtempSync(join(tmpdir(), "codehost-ay-"));
+  writeFileSync(join(dir, "pids.jsonl"), lines.map((l) => JSON.stringify(l)).join("\n") + "\n");
+  return dir;
+}
+
+describe("readAgents", () => {
+  test("last line per pid wins; exited and dead pids are dropped", () => {
+    const dir = makeAyDir([
+      { pid: process.pid, cli: "claude", prompt: "fix the bug", cwd: "/tmp", status: "idle", started_at: 5 },
+      { pid: 99999999, cli: "gemini", cwd: "/tmp", status: "active" }, // dead pid
+      { pid: process.pid, cli: "claude", status: "exited", exit_code: 0 }, // last line per pid wins
+    ]);
+    // The final line marks our (live) pid exited, and the other pid is dead.
+    expect(readAgents(dir)).toHaveLength(0);
+  });
+
+  test("maps a live record to AgentInfo", () => {
+    const dir = makeAyDir([
+      { pid: process.pid, cli: "claude", prompt: "do things", cwd: "/tmp/x", status: "active", started_at: 7 },
+    ]);
+    expect(readAgents(dir)).toEqual([
+      { pid: process.pid, tool: "claude", title: "do things", cwd: "/tmp/x", state: "active", startedAt: 7 },
+    ]);
+  });
+
+  test("missing registry -> empty", () => {
+    expect(readAgents(mkdtempSync(join(tmpdir(), "codehost-ay-empty-")))).toEqual([]);
+  });
+});
+
+describe("plugin routing + meta", () => {
+  test("routePlugins dispatches under /__codehost/<name>/ with the sub-path", async () => {
+    const seen: string[] = [];
+    const plugin = {
+      name: "agent-yes",
+      route: async (path: string) => {
+        seen.push(path);
+        return new Response("ok");
+      },
+    };
+    const res = routePlugins([plugin], {
+      method: "GET",
+      path: "/__codehost/agent-yes/api/ls?active=1",
+      headers: new Headers(),
+    });
+    expect(res).not.toBeNull();
+    await res;
+    expect(seen).toEqual(["/api/ls?active=1"]);
+    expect(
+      routePlugins([plugin], { method: "GET", path: "/__codehost/other/x", headers: new Headers() }),
+    ).toBeNull();
+  });
+
+  test("withPluginMeta merges contributions over the base", () => {
+    const base = { name: "x", cwd: "/", host: "mac" };
+    const merged = withPluginMeta(base, [{ name: "agent-yes", meta: () => ({ agents: [] }) }]);
+    expect(merged).toEqual({ name: "x", cwd: "/", host: "mac", agents: [] });
+  });
+
+  test("agentYesPlugin returns null when the dir doesn't exist", () => {
+    expect(agentYesPlugin("/nonexistent/definitely-not-here")).toBeNull();
+  });
+});