codehost 0.16.0 → 0.17.0

package/src/cli/registry.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, rmSync, statSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+// One-daemon-per-host coordination (Phase 5 of the resource-model redesign).
+// A single VS Code serve-web opens ANY local path via ?folder=, so one root
+// daemon can carry every workspace on the machine: a later `codehost dev`
+// REGISTERS its directory here and exits instead of spawning a second peer +
+// VS Code. The daemon advertises registered dirs in meta.workspaces and
+// re-reads this registry on fs.watch + the slow refresh tick.
+
+export const CODEHOST_DIR = join(homedir(), ".codehost");
+const DAEMON_FILE = join(CODEHOST_DIR, "daemon.json");
+const WORKSPACES_FILE = join(CODEHOST_DIR, "workspaces.json");
+
+/** Written by a foreground root daemon while it runs; staleness is detected by
+ *  pid liveness, so a kill -9 leftover never blocks anything. */
+export interface DaemonPresence {
+  pid: number;
+  /** Real OS path of the served root. */
+  root: string;
+  /** Room token the daemon registered with — later `dev` runs print a link
+   *  into THIS room, since that's where the workspace will appear. */
+  token: string;
+  startedAt: number;
+}
+
+export interface RegisteredWorkspace {
+  /** Real OS path. */
+  path: string;
+  addedAt: number;
+}
+
+export function writeDaemonPresence(p: DaemonPresence, file: string = DAEMON_FILE): void {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(p, null, 2));
+}
+
+export function clearDaemonPresence(file: string = DAEMON_FILE): void {
+  try {
+    rmSync(file);
+  } catch {
+    // already gone
+  }
+}
+
+/** The live host daemon, or null (no file, unparsable, or its pid is dead). */
+export function liveDaemon(file: string = DAEMON_FILE): DaemonPresence | null {
+  try {
+    const p = JSON.parse(readFileSync(file, "utf8")) as DaemonPresence;
+    if (typeof p.pid !== "number" || !p.root || !p.token) return null;
+    process.kill(p.pid, 0);
+    return p;
+  } catch {
+    return null;
+  }
+}
+
+/** Add a directory to the host's workspace registry (idempotent). */
+export function registerWorkspace(path: string, file: string = WORKSPACES_FILE): void {
+  const dir = resolve(path);
+  const all = readRegistry(file);
+  if (all.some((w) => w.path === dir)) return;
+  all.push({ path: dir, addedAt: Date.now() });
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(all, null, 2));
+}
+
+/** Registered workspaces whose directories still exist. */
+export function readRegisteredWorkspaces(file: string = WORKSPACES_FILE): RegisteredWorkspace[] {
+  return readRegistry(file).filter((w) => {
+    try {
+      return statSync(w.path).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
+/** The registry path — daemons fs.watch its directory for instant re-advertise. */
+export function workspacesFile(): string {
+  return WORKSPACES_FILE;
+}
+
+function readRegistry(file: string): RegisteredWorkspace[] {
+  try {
+    if (!existsSync(file)) return [];
+    const arr = JSON.parse(readFileSync(file, "utf8"));
+    return Array.isArray(arr) ? arr.filter((w) => w && typeof w.path === "string") : [];
+  } catch {
+    return [];
+  }
+}

package/src/cli/run-server.ts

@@ -1,8 +1,11 @@
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
 import { type PeerMeta, newPeerId } from "../shared/signaling";
 import { SignalingClient } from "../shared/signaling-client";
 import { RtcDaemon } from "./rtc-daemon";
-import { Tunnel } from "./tunnel";
-import { handleProvision, type ProvisionDeps } from "./provision-server";
+import { type LocalRequest, Tunnel } from "./tunnel";
+import { handleProvision, isProvisionPath, type ProvisionDeps } from "./provision-server";
+import { type DaemonPlugin, routePlugins } from "./plugins/types";
 
 export interface LaunchResult {
   /** Local port to tunnel to. */
@@ -28,8 +31,22 @@ export interface RunServerOptions {
   /** Enables `/__codehost/provision` on the tunnel (serve only — runs the home's
    *  setup.sh). Omitted by `expose`, which has no home/workspace. */
   provision?: ProvisionDeps;
+  /** Recompute the advertised meta (e.g. re-enumerate workspaces). Polled on a
+   *  slow interval and right after each provision; pushed to the room only when
+   *  it actually changed. */
+  refreshMeta?: () => PeerMeta;
+  /** Daemon plugins: tunneled routes under /__codehost/<name>/ (their meta
+   *  contributions are the caller's job, inside `meta`/`refreshMeta`). */
+  plugins?: DaemonPlugin[];
+  /** Files whose change should trigger an immediate `refreshMeta` (e.g. the
+   *  host workspace registry). Watched via their parent directory so the file
+   *  may not exist yet. */
+  watchFiles?: string[];
 }
 
+/** How often a daemon re-enumerates its workspaces (manual clones show up). */
+const META_REFRESH_MS = 60_000;
+
 /**
  * Foreground server loop shared by `serve`, `dev`, and `expose`: register in the
  * signaling room with the given meta and bridge each viewer's data channel to a
@@ -64,20 +81,54 @@ export async function runServer(opts: RunServerOptions): Promise<never> {
     onSignal: (from, data) => rtc.handleSignal(from, data),
   });
 
+  // Re-advertise when the workspace set changes (provision, manual clone).
+  let lastMeta = JSON.stringify(opts.meta);
+  const refreshMeta = () => {
+    if (!opts.refreshMeta) return;
+    const meta = opts.refreshMeta();
+    const s = JSON.stringify(meta);
+    if (s === lastMeta) return;
+    lastMeta = s;
+    client.updateMeta(meta);
+  };
+  const provision: ProvisionDeps | undefined = opts.provision
+    ? { ...opts.provision, onProvisioned: refreshMeta }
+    : undefined;
+  const plugins = opts.plugins ?? [];
+  const onLocal =
+    provision || plugins.length > 0
+      ? (req: LocalRequest) => {
+          if (provision && isProvisionPath(req.path)) return handleProvision(req.path, provision);
+          return routePlugins(plugins, req);
+        }
+      : undefined;
+
   rtc = new RtcDaemon({
     sendSignal: (to, data) => client.sendSignal(to, data),
     onChannel: (viewerId, channel) => {
       console.log(`[codehost] viewer ${viewerId.slice(0, 8)} connected; bridging to :${target.port}`);
-      new Tunnel(
-        channel,
-        target.port,
-        target.stripBasePath,
-        opts.provision ? (rawPath) => handleProvision(rawPath, opts.provision!) : undefined,
-      );
+      new Tunnel(channel, target.port, target.stripBasePath, onLocal);
     },
   });
 
   client.connect();
+  if (opts.refreshMeta) {
+    setInterval(refreshMeta, META_REFRESH_MS);
+    // Instant re-advertise when a watched file changes (debounced — editors
+    // and fs.watch both fire in bursts).
+    let pending: ReturnType<typeof setTimeout> | null = null;
+    for (const file of opts.watchFiles ?? []) {
+      try {
+        watch(dirname(file), (_event, filename) => {
+          if (filename && filename !== basename(file)) return;
+          if (pending) clearTimeout(pending);
+          pending = setTimeout(refreshMeta, 300);
+        });
+      } catch {
+        // missing dir / unsupported platform — the interval still covers it
+      }
+    }
+  }
 
   const shutdown = () => {
     console.log("\n[codehost] shutting down");

package/src/cli/tunnel.ts

@@ -1,5 +1,4 @@
 import type { DataChannel } from "node-datachannel";
-import { isProvisionPath } from "./provision-server";
 import {
   type HttpReqHead,
   Op,
@@ -9,7 +8,6 @@ import {
   encodeFrame,
   encodeJson,
   payloadJson,
-  payloadText,
   wsMessageFrames,
 } from "../shared/protocol";
 
@@ -34,6 +32,19 @@ interface HttpStream {
   body: Uint8Array[];
 }
 
+/** A tunneled request offered to the daemon's local routes before proxying. */
+export interface LocalRequest {
+  method: string;
+  /** Raw tunneled path incl. query (no /vs/<peerId> stripping applied). */
+  path: string;
+  headers: Headers;
+  body?: Uint8Array;
+}
+
+/** Serve `/__codehost/*` requests in-daemon (provisioning, plugins). Return
+ *  null/undefined to fall through to the local-server proxy. */
+export type LocalHandler = (req: LocalRequest) => Promise<Response> | null | undefined;
+
 /**
  * Bridges one WebRTC data channel to a local `code serve-web` instance.
  * Multiplexes concurrent HTTP requests and WebSocket connections by streamId.
@@ -55,9 +66,9 @@ export class Tunnel {
      * doesn't know it, so we strip `/vs/<peerId>` before proxying.
      */
     private stripPrefix?: string,
-    /** Handles `/__codehost/*` requests locally (provisioning) instead of
-     *  forwarding to the local server. Wired only for `serve` (not `expose`). */
-    private onProvision?: (rawPath: string) => Promise<Response>,
+    /** Serves `/__codehost/*` requests locally (provisioning, plugins) instead
+     *  of forwarding to the local server. Wired only for `serve` (not `expose`). */
+    private onLocal?: LocalHandler,
   ) {
     this.origin = `http://127.0.0.1:${vscodePort}`;
     this.wsOrigin = `ws://127.0.0.1:${vscodePort}`;
@@ -138,15 +149,15 @@ export class Tunnel {
     const body = hasBody ? concat(stream.body) : undefined;
 
     try {
-      const res =
-        this.onProvision && isProvisionPath(path)
-          ? await this.onProvision(path)
-          : await fetch(this.origin + this.localPath(path), {
-              method,
-              headers: reqHeaders,
-              body: body as BodyInit | undefined,
-              redirect: "manual",
-            });
+      const local = this.onLocal?.({ method, path, headers: reqHeaders, body });
+      const res = local
+        ? await local
+        : await fetch(this.origin + this.localPath(path), {
+            method,
+            headers: reqHeaders,
+            body: body as BodyInit | undefined,
+            redirect: "manual",
+          });
 
       const resHeaders: Record<string, string> = {};
       res.headers.forEach((v, k) => {

package/src/cli/vscode-install.ts

@@ -49,10 +49,17 @@ export async function resolveCodeBinary(opts: { force?: boolean } = {}): Promise
     return override;
   }
 
-  // Prefer a user-owned `code` on PATH — but only if it actually runs. A broken
-  // or stub `code` should fall through to a managed install/upgrade.
+  // Prefer a user-owned `code` on PATH — but only if it actually runs AND can
+  // `serve-web`. The desktop app's bin/code wrapper passes --version yet treats
+  // `serve-web` as a file path ("Ignoring option 'host': not supported") and
+  // exits 0 without ever listening — so probe the subcommand, not just the
+  // binary (observed on macOS VS Code 1.123: serve started, then "VS Code
+  // server exited (code 0) before becoming ready").
   const system = Bun.which("code");
-  if (system && runsOk(system)) return system;
+  if (system && runsOk(system)) {
+    if (supportsServeWeb(system)) return system;
+    console.warn(`[codehost] system code (${system}) can't serve-web — using a managed VS Code CLI instead`);
+  }
 
   return ensureManagedBinary(opts.force ?? false);
 }
@@ -119,6 +126,16 @@ function runsOk(bin: string): boolean {
   return r.status === 0;
 }
 
+/** True if `<bin> serve-web --help` is a real subcommand: clean exit, no
+ *  desktop-wrapper "Ignoring option" complaints, and help text that actually
+ *  mentions serve-web. (Run with --help so nothing starts listening.) */
+function supportsServeWeb(bin: string): boolean {
+  const r = spawnSync(bin, ["serve-web", "--help"], { encoding: "utf8", timeout: 10_000 });
+  if (r.status !== 0) return false;
+  const out = `${r.stdout ?? ""}${r.stderr ?? ""}`;
+  return !/ignoring option/i.test(out) && /serve-web/i.test(out);
+}
+
 function isMusl(): boolean {
   if (existsSync("/etc/alpine-release")) return true;
   // `ldd --version` mentions "musl" on musl systems; ignore failures.

package/src/cli/workspaces.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_LAYOUT } from "../shared/repo";
+import { enumerateWorkspaces } from "./workspaces";
+
+function makeRoot(): string {
+  return mkdtempSync(join(tmpdir(), "codehost-ws-"));
+}
+
+/** Create a checkout dir; .git is a dir by default, a file when `worktree`. */
+function checkout(root: string, rel: string, worktree = false): void {
+  const dir = join(root, rel);
+  mkdirSync(dir, { recursive: true });
+  if (worktree) writeFileSync(join(dir, ".git"), "gitdir: elsewhere");
+  else mkdirSync(join(dir, ".git"));
+}
+
+describe("enumerateWorkspaces", () => {
+  test("walks the default layout and reports repo identity + branch", () => {
+    const root = makeRoot();
+    checkout(root, "snomiao/codehost/tree/main");
+    checkout(root, "symval/symval/tree/dev", true); // worktree-style .git file
+    mkdirSync(join(root, "snomiao/empty/tree/main"), { recursive: true }); // no .git
+
+    const found = enumerateWorkspaces(root, DEFAULT_LAYOUT);
+    expect(found).toHaveLength(2);
+    expect(found).toContainEqual({
+      path: join(root, "snomiao/codehost/tree/main"),
+      repo: "github.com/snomiao/codehost",
+      branch: "main",
+    });
+    expect(found).toContainEqual({
+      path: join(root, "symval/symval/tree/dev"),
+      repo: "github.com/symval/symval",
+      branch: "dev",
+    });
+  });
+
+  test("literal segments must exist; placeholders match one level", () => {
+    const root = makeRoot();
+    checkout(root, "ws/snomiao/codehost"); // layout ws/{owner}/{repo}
+    checkout(root, "other/snomiao/codehost"); // doesn't match the literal "ws"
+
+    const found = enumerateWorkspaces(root, "ws/{owner}/{repo}");
+    expect(found).toHaveLength(1);
+    expect(found[0].repo).toBe("github.com/snomiao/codehost");
+    expect(found[0].branch).toBeUndefined();
+  });
+
+  test("skips dot-directories and tolerates a missing root", () => {
+    const root = makeRoot();
+    checkout(root, ".hidden/codehost/tree/main");
+    expect(enumerateWorkspaces(root, DEFAULT_LAYOUT)).toHaveLength(0);
+    expect(enumerateWorkspaces(join(root, "nope"), DEFAULT_LAYOUT)).toHaveLength(0);
+  });
+
+  test("uses the given git host in repo identity", () => {
+    const root = makeRoot();
+    checkout(root, "group/proj/tree/main");
+    const found = enumerateWorkspaces(root, DEFAULT_LAYOUT, "gitlab.com");
+    expect(found[0].repo).toBe("gitlab.com/group/proj");
+  });
+});

package/src/cli/workspaces.ts

@@ -0,0 +1,80 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { GITHUB_HOST, toPosixPath } from "../shared/repo";
+import type { WorkspaceInfo } from "../shared/signaling";
+
+// Enumerate the checkouts that exist under a root daemon's home by walking the
+// workspace layout template (e.g. "{owner}/{repo}/tree/{branch}") one segment
+// at a time: a literal segment must exist, a placeholder segment matches one
+// directory level. A leaf only counts as a workspace when it holds a `.git`
+// (directory, or file for a worktree). Feeds PeerMeta.workspaces.
+
+/** Cap the advertised list (meta rides the signaling room broadcast). */
+const MAX_WORKSPACES = 200;
+/** Cap the intermediate walk so a huge home dir can't blow up enumeration. */
+const MAX_FRONTIER = 1000;
+
+export function enumerateWorkspaces(rootDir: string, layout: string, host = GITHUB_HOST): WorkspaceInfo[] {
+  let frontier = [{ dir: rootDir, vars: {} as Record<string, string> }];
+  for (const seg of layout.split("/").filter(Boolean)) {
+    const names = [...seg.matchAll(/\{(\w+)\}/g)].map((m) => m[1]);
+    const next: typeof frontier = [];
+    for (const f of frontier) {
+      if (next.length >= MAX_FRONTIER) break;
+      if (names.length === 0) {
+        const dir = join(f.dir, seg);
+        if (isDir(dir)) next.push({ dir, vars: f.vars });
+        continue;
+      }
+      const re = segmentPattern(seg);
+      for (const name of listDirs(f.dir)) {
+        if (next.length >= MAX_FRONTIER) break;
+        if (name.startsWith(".")) continue;
+        const m = re.exec(name);
+        if (!m) continue;
+        const vars = { ...f.vars };
+        names.forEach((n, i) => (vars[n] = m[i + 1]));
+        next.push({ dir: join(f.dir, name), vars });
+      }
+    }
+    frontier = next;
+    if (frontier.length === 0) return [];
+  }
+
+  const out: WorkspaceInfo[] = [];
+  for (const f of frontier) {
+    if (out.length >= MAX_WORKSPACES) break;
+    if (!existsSync(join(f.dir, ".git"))) continue;
+    const { owner, repo, branch } = f.vars;
+    out.push({
+      path: toPosixPath(f.dir),
+      ...(owner && repo ? { repo: `${host}/${owner}/${repo}` } : {}),
+      ...(branch ? { branch } : {}),
+    });
+  }
+  return out;
+}
+
+/** A layout segment as a matcher: literals exact, `{name}`s capture. */
+function segmentPattern(seg: string): RegExp {
+  const escaped = seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped.replace(/\\\{\w+\\\}/g, "([^/]+)")}$`);
+}
+
+function isDir(p: string): boolean {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listDirs(p: string): string[] {
+  try {
+    return readdirSync(p, { withFileTypes: true })
+      .filter((e) => e.isDirectory() || e.isSymbolicLink())
+      .map((e) => e.name);
+  } catch {
+    return [];
+  }
+}

package/src/shared/repo.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { gitUrlToPath, parseDeepLink, pickRoomMatch, repoKey, resolveDevTarget, resolveRepoTarget, shareableDeepLink, toPosixPath } from "./repo";
-import type { PeerInfo } from "./signaling";
+import type { PeerInfo, WorkspaceInfo } from "./signaling";
 import { parseGitRemote } from "../cli/git";
 
 describe("toPosixPath", () => {
@@ -217,6 +217,115 @@ describe("resolveRepoTarget root selection", () => {
   });
 });
 
+describe("resolveDevTarget advertised workspaces", () => {
+  const root: PeerInfo = {
+    peerId: "root1",
+    role: "server",
+    meta: {
+      name: "mac",
+      host: "mbp",
+      cwd: "/Users/sno",
+      kind: "root",
+      workspaces: [{ path: "/Users/sno/scratch/tool" }],
+    },
+  };
+
+  test("a /host/<host>/<path> link matches a registered workspace on a root daemon", () => {
+    const res = resolveDevTarget([root], { host: "mbp", path: "/Users/sno/scratch/tool" });
+    expect(res?.peerId).toBe("root1");
+    expect(res?.folder).toBe("/Users/sno/scratch/tool");
+    expect(res?.exact).toBe(true);
+  });
+
+  test("host scoping still applies to workspace matches", () => {
+    expect(resolveDevTarget([root], { host: "other", path: "/Users/sno/scratch/tool" })).toBeNull();
+  });
+
+  test("an exact cwd mount still wins (no folder synthesized)", () => {
+    const res = resolveDevTarget([root], { host: "mbp", path: "/Users/sno" });
+    expect(res).toEqual({ peerId: "root1" });
+  });
+});
+
+describe("resolveRepoTarget enumerated workspaces (exact)", () => {
+  const target = { host: "github.com", owner: "snomiao", name: "codehost" };
+  const root = (peerId: string, cwd: string, workspaces?: WorkspaceInfo[]): PeerInfo => ({
+    peerId,
+    role: "server",
+    meta: { name: peerId, host: "Mac", cwd, kind: "root", workspaces },
+  });
+
+  test("an enumerated checkout beats a deeper root's synthesized fallback", () => {
+    const servers = [
+      root("deep", "/Users/sno/ws"),
+      root("listed", "/Users/sno", [
+        { path: "/Users/sno/snomiao/codehost/tree/main", repo: "github.com/snomiao/codehost", branch: "main" },
+      ]),
+    ];
+    const res = resolveRepoTarget(servers, target);
+    expect(res?.peerId).toBe("listed");
+    expect(res?.folder).toBe("/Users/sno/snomiao/codehost/tree/main");
+    expect(res?.exact).toBe(true);
+  });
+
+  test("branch mismatch falls back to the synthesized path", () => {
+    const servers = [
+      root("listed", "/Users/sno/ws", [
+        { path: "/Users/sno/ws/snomiao/codehost/tree/main", repo: "github.com/snomiao/codehost", branch: "main" },
+      ]),
+    ];
+    const res = resolveRepoTarget(servers, { ...target, branch: "dev" });
+    expect(res?.exact).toBeUndefined();
+    expect(res?.folder).toBe("/Users/sno/ws/snomiao/codehost/tree/dev");
+  });
+
+  test("pickRoomMatch ranks an exact enumerated match like a repo daemon", () => {
+    const fallback = { token: "room-a", resolution: { peerId: "x", folder: "/a/b" } };
+    const exact = { token: "room-b", resolution: { peerId: "y", folder: "/c/d", exact: true } };
+    expect(pickRoomMatch([fallback, exact])?.token).toBe("room-b");
+  });
+});
+
+describe("resolveRepoTarget machine preference (history)", () => {
+  const target = { host: "github.com", owner: "snomiao", name: "codehost" };
+  const repoDaemon = (peerId: string, hostId?: string, host = "Mac"): PeerInfo => ({
+    peerId,
+    role: "server",
+    meta: { name: peerId, host, hostId, cwd: "/x", repo: "github.com/snomiao/codehost" },
+  });
+  const root = (peerId: string, cwd: string, hostId?: string, host = "Mac"): PeerInfo => ({
+    peerId,
+    role: "server",
+    meta: { name: peerId, host, hostId, cwd, kind: "root" },
+  });
+
+  test("among equal repo daemons, prefers the history hostId", () => {
+    const servers = [repoDaemon("a", "id-a"), repoDaemon("b", "id-b")];
+    expect(resolveRepoTarget(servers, target, { hostId: "id-b" })?.peerId).toBe("b");
+    expect(resolveRepoTarget(servers, target, { hostId: "id-a" })?.peerId).toBe("a");
+  });
+
+  test("hostname fallback matches entries/daemons without a hostId", () => {
+    const servers = [repoDaemon("a", undefined, "mbp"), repoDaemon("b", undefined, "win")];
+    expect(resolveRepoTarget(servers, target, { host: "win" })?.peerId).toBe("b");
+  });
+
+  test("preferred root beats a deeper root on another machine", () => {
+    const servers = [root("deep", "/Users/sno/ws/x", "id-other"), root("mine", "/Users/sno", "id-mine")];
+    expect(resolveRepoTarget(servers, target, { hostId: "id-mine" })?.peerId).toBe("mine");
+  });
+
+  test("no preference keeps the existing order (deepest root, first repo daemon)", () => {
+    const servers = [root("shallow", "/Users/sno", "id-1"), root("deep", "/Users/sno/ws", "id-2")];
+    expect(resolveRepoTarget(servers, target)?.peerId).toBe("deep");
+  });
+
+  test("a stale preference (machine offline) falls back gracefully", () => {
+    const servers = [repoDaemon("a", "id-a")];
+    expect(resolveRepoTarget(servers, target, { hostId: "gone" })?.peerId).toBe("a");
+  });
+});
+
 describe("gitUrlToPath", () => {
   test("github URLs -> /gh, preserving branch (incl. slashes)", () => {
     expect(gitUrlToPath("https://github.com/snomiao/codehost")).toBe("/gh/snomiao/codehost");