codehost 0.16.0 → 0.18.0

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");

package/src/shared/repo.ts

@@ -173,26 +173,66 @@ export interface Resolution {
   peerId: string;
   /** Folder to open via ?folder= (root kind); undefined opens the repo as-is. */
   folder?: string;
+  /** The folder is a checkout the daemon *enumerated* (it exists on disk), not
+   *  an optimistic layout-synthesized path — rank it like an exact match. */
+  exact?: boolean;
+}
+
+/** Machine preference (from history) used to break ties between matches. */
+export interface ResolvePrefs {
+  /** Stable machine id — prefer servers advertising it. */
+  hostId?: string;
+  /** Hostname fallback for pre-hostId daemons/entries. */
+  host?: string;
+}
+
+function prefers(meta: PeerMeta | null | undefined, prefer?: ResolvePrefs): boolean {
+  if (!prefer || !meta) return false;
+  if (prefer.hostId && meta.hostId) return meta.hostId === prefer.hostId;
+  return !!prefer.host && meta.host === prefer.host;
 }
 
 /**
  * Pick the best live server for a repo deep link. Prefers an exact `repo`
  * daemon; otherwise falls back to a `root` daemon that can open the subfolder.
- * Among several roots, prefers the **deepest** (longest cwd) — with a nested
- * setup like /Users/sno and /Users/sno/ws both serving, the layout subfolder
- * exists under the deeper one (observed: /gh/snomiao/codehost belongs to
- * /Users/sno/ws/..., not /Users/sno/...). Returns null if nothing matches.
+ * Ties (several repo daemons, or several roots) break toward the machine in
+ * `prefer` — the one history says served this repo last. Among several roots,
+ * then prefers the **deepest** (longest cwd) — with a nested setup like
+ * /Users/sno and /Users/sno/ws both serving, the layout subfolder exists under
+ * the deeper one (observed: /gh/snomiao/codehost belongs to /Users/sno/ws/...,
+ * not /Users/sno/...). Returns null if nothing matches.
  */
-export function resolveRepoTarget(servers: PeerInfo[], target: RepoTarget): Resolution | null {
+export function resolveRepoTarget(
+  servers: PeerInfo[],
+  target: RepoTarget,
+  prefer?: ResolvePrefs,
+): Resolution | null {
   const key = repoKey(target);
-  const repoMatch = servers.find(
+  const repoMatches = servers.filter(
     (s) => s.meta?.kind !== "root" && s.meta?.repo === key && branchOk(s.meta, target),
   );
+  const repoMatch = repoMatches.find((s) => prefers(s.meta, prefer)) ?? repoMatches[0];
   if (repoMatch) return { peerId: repoMatch.peerId };
 
-  const root = servers
+  const roots = servers
     .filter((s) => s.meta?.kind === "root")
-    .sort((a, b) => (b.meta?.cwd.length ?? 0) - (a.meta?.cwd.length ?? 0))[0];
+    .sort(
+      (a, b) =>
+        Number(prefers(b.meta, prefer)) - Number(prefers(a.meta, prefer)) ||
+        (b.meta?.cwd.length ?? 0) - (a.meta?.cwd.length ?? 0),
+    );
+
+  // A root that *enumerated* a matching checkout knows it exists on disk —
+  // rank it exact, ahead of any synthesized fallback.
+  const wantBranch = target.branch || DEFAULT_BRANCH;
+  for (const s of roots) {
+    const ws = s.meta?.workspaces?.find(
+      (w) => w.repo === key && (!w.branch || w.branch === wantBranch),
+    );
+    if (ws) return { peerId: s.peerId, folder: ws.path, exact: true };
+  }
+
+  const root = roots[0];
   if (root && root.meta) {
     const folder = `${trimSlash(root.meta.cwd)}/${fillLayout(root.meta.layout || DEFAULT_LAYOUT, target)}`;
     return { peerId: root.peerId, folder };
@@ -204,13 +244,20 @@ export function resolveRepoTarget(servers: PeerInfo[], target: RepoTarget): Reso
  *  to `target.host` when the link carries one (a bare path is ambiguous across
  *  machines). Compares with leading + trailing slashes stripped: `parseDeepLink`
  *  forces a leading "/" on the path, but a served cwd may lack one (e.g. an
- *  `expose` server's `localhost:<port>`), so a trailing-only trim never matches. */
+ *  `expose` server's `localhost:<port>`), so a trailing-only trim never matches.
+ *  A root daemon whose *advertised workspaces* include the path matches too —
+ *  that's how directories registered with the host daemon resolve. */
 export function resolveDevTarget(servers: PeerInfo[], target: DevTarget): Resolution | null {
   const want = stripEnds(target.path);
-  const hit = servers.find(
-    (s) => s.meta && stripEnds(s.meta.cwd) === want && (!target.host || s.meta.host === target.host),
-  );
-  return hit ? { peerId: hit.peerId } : null;
+  const hostOk = (meta: PeerMeta) => !target.host || meta.host === target.host;
+  const hit = servers.find((s) => s.meta && stripEnds(s.meta.cwd) === want && hostOk(s.meta));
+  if (hit) return { peerId: hit.peerId };
+  for (const s of servers) {
+    if (!s.meta || !hostOk(s.meta)) continue;
+    const ws = s.meta.workspaces?.find((w) => stripEnds(w.path) === want);
+    if (ws) return { peerId: s.peerId, folder: ws.path, exact: true };
+  }
+  return null;
 }
 
 /** A candidate room (its token) plus how the deep link resolved within it. */
@@ -221,14 +268,15 @@ export interface RoomMatch {
 
 /**
  * Rank matches found while searching multiple rooms for a token-less deep link.
- * An *exact* match (a server that genuinely serves this repo/folder — no
- * synthesized `folder`) beats a *root fallback* (a root daemon that would open
- * the repo as a subfolder, which `resolveRepoTarget` returns for ANY repo link).
- * Without this preference, first-responder-wins could pick an unrelated room
- * that merely has a root server. Returns null when there are no matches.
+ * An *exact* match (a server that genuinely serves this repo/folder — a repo
+ * daemon, or a root whose enumerated checkout matched) beats a *root fallback*
+ * (a root daemon that would open the repo as a synthesized subfolder, which
+ * `resolveRepoTarget` returns for ANY repo link). Without this preference,
+ * first-responder-wins could pick an unrelated room that merely has a root
+ * server. Returns null when there are no matches.
  */
 export function pickRoomMatch(matches: RoomMatch[]): RoomMatch | null {
-  return matches.find((m) => !m.resolution.folder) ?? matches[0] ?? null;
+  return matches.find((m) => !m.resolution.folder || m.resolution.exact) ?? matches[0] ?? null;
 }
 
 function branchOk(meta: PeerMeta, target: RepoTarget): boolean {

package/src/shared/signaling-client.ts

@@ -161,6 +161,16 @@ export class SignalingClient {
     this.ws?.send(JSON.stringify(msg));
   }
 
+  /** Replace the advertised metadata: a live socket pushes it to the room now,
+   *  and every future (re)connect's `hello` carries it. */
+  updateMeta(meta: PeerMeta): void {
+    this.opts.meta = meta;
+    if (this.ws?.readyState === 1 /* OPEN */) {
+      const msg: ClientMessage = { type: "meta", meta };
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
   close(): void {
     this.closed = true;
     this.stopHeartbeat();

package/src/shared/signaling.ts

@@ -4,6 +4,34 @@
 
 export type Role = "server" | "viewer";
 
+/** One live agent CLI session on the daemon's machine (sourced from agent-yes's
+ *  registry) — advertised so clients can see which agents run where. Interact
+ *  with it over the tunnel's `/__codehost/agent-yes/*` proxy. */
+export interface AgentInfo {
+  pid: number;
+  /** CLI the agent runs, e.g. "claude", "codex". */
+  tool: string;
+  /** Prompt/note snippet for display. */
+  title?: string;
+  /** Working directory (?folder= form) — ties an agent to a workspace. */
+  cwd: string;
+  state: "active" | "idle";
+  /** Unix ms when the agent started. */
+  startedAt?: number;
+}
+
+/** One checkout a root daemon found on disk under its layout — advertised so
+ *  clients can list and exactly match real workspaces instead of synthesizing
+ *  optimistic paths. */
+export interface WorkspaceInfo {
+  /** ?folder= form path of the checkout (see toPosixPath). */
+  path: string;
+  /** Host-agnostic repo identity, e.g. "github.com/owner/repo". */
+  repo?: string;
+  /** Branch from the layout path, e.g. "main". */
+  branch?: string;
+}
+
 /** Metadata a `codehost serve`/`dev` daemon advertises about itself. */
 export interface PeerMeta {
   /** Human label, defaults to hostname. */
@@ -12,6 +40,13 @@ export interface PeerMeta {
   cwd: string;
   /** Hostname of the machine running the daemon. */
   host: string;
+  /**
+   * Stable machine identity (UUID persisted in ~/.codehost/config.json). All
+   * daemons on one machine share it, unlike the per-process peerId, so clients
+   * can group peers by host and keep history across daemon restarts. Absent on
+   * older daemons — fall back to `host`.
+   */
+  hostId?: string;
   /**
    * "repo": serves a single folder (`codehost dev`), git-identified when possible.
    * "root": serves a workspace root (`codehost serve`) whose repos live under it.
@@ -28,6 +63,17 @@ export interface PeerMeta {
    * `cwd + "/" + fill(layout, target)`.
    */
   layout?: string;
+  /**
+   * root kind: the checkouts that actually exist under `cwd` (enumerated on
+   * start, after each provision, and on a slow rescan). Capped server-side;
+   * absent on older daemons and on repo/expose kinds.
+   */
+  workspaces?: WorkspaceInfo[];
+  /**
+   * Live agent CLI sessions on this machine (from the agent-yes plugin).
+   * Advertised by root daemons; capped server-side.
+   */
+  agents?: AgentInfo[];
 }
 
 export interface PeerInfo {
@@ -61,7 +107,15 @@ export interface PingMessage {
   type: "ping";
 }
 
-export type ClientMessage = HelloMessage | SignalMessage | PingMessage;
+/** Replace this peer's advertised metadata mid-session (e.g. a provision
+ *  created a new workspace) — the room re-broadcasts the peer list. Older
+ *  workers ignore it; the meta still lands via `hello` on the next reconnect. */
+export interface MetaMessage {
+  type: "meta";
+  meta: PeerMeta;
+}
+
+export type ClientMessage = HelloMessage | SignalMessage | PingMessage | MetaMessage;
 
 // ---- Server -> Client ----