codehost 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.5.1](https://github.com/snomiao/codehost/compare/v0.5.0...v0.5.1) (2026-06-08)
+
+
+### Bug Fixes
+
+* don't time out (and oxmgr-restart-loop) on first-run VS Code server download ([5ad1b06](https://github.com/snomiao/codehost/commit/5ad1b068668afda4d19f403286240827a0a4b9c4))
+* Windows ?folder= path must be /C:/ws (file-URI form), not git-bash /c/ws ([f6d2485](https://github.com/snomiao/codehost/commit/f6d24858c943dd2b7b5f1d5a96f71468e9552140))
+
+# [0.5.0](https://github.com/snomiao/codehost/compare/v0.4.0...v0.5.0) (2026-06-08)
+
+
+### Features
+
+* shareable workspace URLs (host-agnostic) + Share button + cross-room search ([f1db806](https://github.com/snomiao/codehost/commit/f1db806a1ec86cdc369b17ccca82057eb9526385))
+
 # [0.4.0](https://github.com/snomiao/codehost/compare/v0.3.1...v0.4.0) (2026-06-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "repository": {
     "type": "git",

package/src/cli/commands/dev.ts

@@ -23,7 +23,7 @@ interface DevArgs {
 export const devCommand: CommandModule<{}, DevArgs> = {
   command: "dev [dir]",
   describe:
-    "Serve a single folder over WebRTC; open it at codehost.dev/dev/<path> (or /gh/<owner>/<repo> when it's a GitHub repo)",
+    "Serve a single folder over WebRTC; open it at codehost.dev/dev/<path> (or /gh/<owner>/<repo>, /git/<host>/<owner>/<repo> for a git repo)",
   builder: (y) =>
     y
       .positional("dir", {
@@ -86,8 +86,8 @@ export const devCommand: CommandModule<{}, DevArgs> = {
     const id = repoIdentity(dir);
     const meta: PeerMeta = {
       name: argv.name ?? host,
-      // POSIX-drive form for the browser (C:\ws -> /c/ws); `dir` stays the real
-      // OS path for the local VS Code working dir.
+      // VS Code-web ?folder= form for the browser (C:\ws -> /C:/ws); `dir` stays
+      // the real OS path for the local VS Code working dir.
       cwd: toPosixPath(dir),
       host,
       kind: "repo",

package/src/cli/commands/serve.ts

@@ -23,7 +23,7 @@ interface ServeArgs {
 export const serveCommand: CommandModule<{}, ServeArgs> = {
   command: "serve [dir]",
   describe:
-    "Serve a workspace root over WebRTC; repos under it open via codehost.dev/gh/<owner>/<repo>",
+    "Serve a workspace root over WebRTC; repos under it open via codehost.dev/gh/<owner>/<repo> (or /git/<host>/<owner>/<repo>)",
   builder: (y) =>
     y
       .positional("dir", {
@@ -87,7 +87,7 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     // onto subfolders via VS Code's ?folder= using this layout.
     const meta: PeerMeta = {
       name: argv.name ?? host,
-      // POSIX-drive form for the browser ?folder= URI (C:\ws -> /c/ws); the real
+      // 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,

package/src/cli/git.ts

@@ -1,11 +1,13 @@
 import { spawnSync } from "node:child_process";
 
-// Derive a normalized repo identity ("gh/<owner>/<repo>") + branch from a git
-// working tree, so a `codehost dev` daemon can be addressed by GitHub-shaped
-// deep links. Best-effort: returns undefined fields off git / off GitHub.
+// Derive a normalized, host-agnostic repo identity ("<host>/<owner>/<repo>") +
+// branch from a git working tree, so a `codehost dev` daemon can be addressed by
+// deep links (/gh/<owner>/<repo> for GitHub, /git/<host>/<owner>/<repo> for any
+// other host). Best-effort: returns undefined fields off git / off a recognized
+// remote.
 
 export interface RepoIdentity {
-  /** Normalized identity, e.g. "gh/snomiao/codehost". */
+  /** Normalized identity, e.g. "github.com/snomiao/codehost". */
   repo?: string;
   /** Current branch, e.g. "main". */
   branch?: string;
@@ -24,27 +26,45 @@ export function repoIdentity(dir: string): RepoIdentity {
   const branch =
     git(dir, ["rev-parse", "--abbrev-ref", "HEAD"]) || git(dir, ["symbolic-ref", "--short", "HEAD"]);
   return {
-    repo: parseGitHubRemote(remote),
+    repo: parseGitRemote(remote),
     branch: branch && branch !== "HEAD" ? branch : undefined,
   };
 }
 
 /**
- * Parse a GitHub remote URL into "gh/<owner>/<repo>". Handles:
+ * Parse any git remote URL into a host-agnostic "<host>/<owner>/<repo>" key
+ * (lowercased host, no trailing `.git`). Handles:
  *   https://github.com/owner/repo(.git)
- *   git@github.com:owner/repo(.git)
- *   ssh://git@github.com/owner/repo(.git)
- * Returns undefined for non-GitHub or unparseable remotes.
+ *   git@gitlab.com:owner/repo(.git)            (scp-like)
+ *   ssh://git@git.company.com:2222/owner/repo  (with optional user/port)
+ *   git://host/owner/repo
+ * Returns undefined for unparseable remotes. Only the first two path segments
+ * (owner/repo) are used; deeper paths (e.g. GitLab subgroups) collapse to those.
  */
-export function parseGitHubRemote(url: string): string | undefined {
-  const u = url.trim();
+export function parseGitRemote(url: string): string | undefined {
+  let u = url.trim();
   if (!u) return undefined;
-  const m = u.match(/github\.com[/:]([^/]+)\/(.+?)(?:\.git)?\/?$/i);
-  if (!m) return undefined;
-  const owner = m[1];
-  const repo = m[2];
-  if (!owner || !repo) return undefined;
-  return `gh/${owner}/${repo}`;
+  u = u.replace(/\.git\/?$/i, "");
+
+  let host: string | undefined;
+  let path: string | undefined;
+
+  // scp-like syntax: [user@]host:owner/repo (no scheme).
+  const scp = u.match(/^(?:[^@/]+@)?([^/:]+):(.+)$/);
+  // URL syntax: scheme://[user@]host[:port]/owner/repo
+  const uri = u.match(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+)$/i);
+  if (uri) {
+    host = uri[1];
+    path = uri[2];
+  } else if (scp && !u.includes("://")) {
+    host = scp[1];
+    path = scp[2];
+  }
+  if (!host || !path) return undefined;
+
+  const segs = path.replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segs.length < 2) return undefined;
+  return `${host.toLowerCase()}/${segs[0]}/${segs[1]}`;
 }
 
 function git(dir: string, args: string[]): string {

package/src/cli/vscode.ts

@@ -1,6 +1,13 @@
 import { spawn, type Subprocess } from "bun";
 import { resolveCodeBinary } from "./vscode-install";
 
+// How long to wait for `code serve-web` to answer. The default is generous
+// because the FIRST run downloads the server component, which can take minutes
+// on a slow link or a fresh Windows box — and under the oxmgr daemon
+// (`--restart on-failure`) a too-short timeout makes us exit mid-download, get
+// restarted, and re-download forever. Override with CODEHOST_VSCODE_READY_TIMEOUT_MS.
+const READY_TIMEOUT_MS = Number(process.env.CODEHOST_VSCODE_READY_TIMEOUT_MS) || 10 * 60_000;
+
 export interface VscodeServer {
   port: number;
   basePath: string;
@@ -49,7 +56,7 @@ export async function launchVscode(opts: LaunchOptions): Promise<VscodeServer> {
   });
 
   const base = `http://127.0.0.1:${port}${opts.basePath}/`;
-  await waitForHttp(base, 30_000);
+  await waitForHttp(base, READY_TIMEOUT_MS, proc);
   console.log(`[codehost] VS Code ready at ${base}`);
 
   const stop = () => {
@@ -62,18 +69,33 @@ export async function launchVscode(opts: LaunchOptions): Promise<VscodeServer> {
   return { port, basePath: opts.basePath, proc, stop };
 }
 
-async function waitForHttp(url: string, timeoutMs: number): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
+async function waitForHttp(url: string, timeoutMs: number, proc?: Subprocess): Promise<void> {
+  const started = Date.now();
+  const deadline = started + timeoutMs;
+  let nextHeartbeat = started + 15_000;
   while (Date.now() < deadline) {
+    // If the server process died (bad flag, crash), fail now instead of waiting
+    // out the whole timeout — and surface that it exited rather than hung.
+    if (proc && proc.exitCode !== null) {
+      throw new Error(`VS Code server exited (code ${proc.exitCode}) before becoming ready at ${url}`);
+    }
     try {
       const res = await fetch(url, { redirect: "manual" });
       if (res.status > 0) return;
     } catch {
       // not up yet
     }
+    if (Date.now() >= nextHeartbeat) {
+      const secs = Math.round((Date.now() - started) / 1000);
+      console.log(`[codehost] waiting for VS Code server to start… (${secs}s; first run downloads the server component)`);
+      nextHeartbeat += 15_000;
+    }
     await Bun.sleep(300);
   }
-  throw new Error(`VS Code did not become ready at ${url} within ${timeoutMs}ms`);
+  throw new Error(
+    `VS Code did not become ready at ${url} within ${timeoutMs}ms ` +
+      `(first-run server download can be slow — raise CODEHOST_VSCODE_READY_TIMEOUT_MS)`,
+  );
 }
 
 async function freePort(): Promise<number> {

package/src/shared/repo.test.ts

@@ -1,24 +1,27 @@
 import { describe, expect, test } from "bun:test";
-import { toPosixPath } from "./repo";
+import { parseDeepLink, pickRoomMatch, repoKey, shareableDeepLink, toPosixPath } from "./repo";
+import { parseGitRemote } from "../cli/git";
 
 describe("toPosixPath", () => {
-  test("Windows drive path -> POSIX drive form", () => {
-    expect(toPosixPath("C:\\ws")).toBe("/c/ws");
-    expect(toPosixPath("C:\\Users\\x")).toBe("/c/Users/x");
+  // VS Code web's ?folder= on Windows wants the file-URI authority form
+  // (/C:/ws), NOT git-bash /c/ws — the latter reports "workspace does not exist".
+  test("Windows drive path -> /<Drive>:/... (file-URI form)", () => {
+    expect(toPosixPath("C:\\ws")).toBe("/C:/ws");
+    expect(toPosixPath("C:\\Users\\taku")).toBe("/C:/Users/taku");
   });
 
-  test("lowercases the drive letter", () => {
-    expect(toPosixPath("D:\\foo")).toBe("/d/foo");
-    expect(toPosixPath("c:\\ws")).toBe("/c/ws");
+  test("preserves drive-letter case (drive is case-insensitive on Windows)", () => {
+    expect(toPosixPath("D:\\foo")).toBe("/D:/foo");
+    expect(toPosixPath("c:\\ws")).toBe("/c:/ws");
   });
 
-  test("drive root collapses to /<letter> (no trailing slash)", () => {
-    expect(toPosixPath("C:\\")).toBe("/c");
-    expect(toPosixPath("C:")).toBe("/c");
+  test("drive root collapses to /<Drive>: (no trailing slash)", () => {
+    expect(toPosixPath("C:\\")).toBe("/C:");
+    expect(toPosixPath("C:")).toBe("/C:");
   });
 
   test("forward-slash Windows paths normalize too", () => {
-    expect(toPosixPath("C:/ws")).toBe("/c/ws");
+    expect(toPosixPath("C:/ws")).toBe("/C:/ws");
   });
 
   test("POSIX absolute paths are unchanged (mac/linux not broken)", () => {
@@ -27,11 +30,136 @@ describe("toPosixPath", () => {
     expect(toPosixPath("/")).toBe("/");
   });
 
-  test("already-normalized POSIX-drive path is a no-op", () => {
-    expect(toPosixPath("/c/ws")).toBe("/c/ws");
+  test("already-normalized path is idempotent", () => {
+    expect(toPosixPath("/C:/ws")).toBe("/C:/ws");
   });
 
   test("trims trailing backslashes/slashes on a drive path", () => {
-    expect(toPosixPath("C:\\ws\\")).toBe("/c/ws");
+    expect(toPosixPath("C:\\ws\\")).toBe("/C:/ws");
+  });
+
+  // Regression: the value VS Code web receives via ?folder= (URL-decoded) must
+  // be exactly /C:/ws so serve-web resolves it to the real C:\ws on disk.
+  test("?folder= round-trip: encode(toPosixPath) decodes back to /C:/ws", () => {
+    const folderParam = encodeURIComponent(toPosixPath("C:\\ws"));
+    expect(folderParam).toBe("%2FC%3A%2Fws");
+    expect(decodeURIComponent(folderParam)).toBe("/C:/ws");
+  });
+});
+
+describe("parseGitRemote", () => {
+  test("GitHub https / ssh / git@ -> host-agnostic key", () => {
+    expect(parseGitRemote("https://github.com/snomiao/codehost.git")).toBe("github.com/snomiao/codehost");
+    expect(parseGitRemote("git@github.com:snomiao/codehost.git")).toBe("github.com/snomiao/codehost");
+    expect(parseGitRemote("ssh://git@github.com/snomiao/codehost")).toBe("github.com/snomiao/codehost");
+  });
+
+  test("other hosts work too (gitlab, bitbucket, self-hosted with port)", () => {
+    expect(parseGitRemote("https://gitlab.com/group/proj.git")).toBe("gitlab.com/group/proj");
+    expect(parseGitRemote("git@bitbucket.org:team/repo.git")).toBe("bitbucket.org/team/repo");
+    expect(parseGitRemote("ssh://git@git.company.com:2222/team/svc.git")).toBe("git.company.com/team/svc");
+  });
+
+  test("lowercases host, strips .git, ignores deeper path segments", () => {
+    expect(parseGitRemote("https://GitHub.com/Owner/Repo")).toBe("github.com/Owner/Repo");
+    expect(parseGitRemote("https://gitlab.com/group/sub/proj.git")).toBe("gitlab.com/group/sub");
+  });
+
+  test("returns undefined for empty / unparseable / single-segment remotes", () => {
+    expect(parseGitRemote("")).toBeUndefined();
+    expect(parseGitRemote("not a url")).toBeUndefined();
+    expect(parseGitRemote("https://github.com/onlyowner")).toBeUndefined();
+  });
+});
+
+describe("parseDeepLink + repoKey round-trip", () => {
+  test("/gh/owner/repo -> github.com key", () => {
+    const dl = parseDeepLink("/gh/snomiao/codehost");
+    expect(dl?.type).toBe("repo");
+    if (dl?.type === "repo") {
+      expect(repoKey(dl.target)).toBe("github.com/snomiao/codehost");
+      expect(dl.target.branch).toBeUndefined();
+    }
+  });
+
+  test("/gh/owner/repo/tree/branch keeps the branch (slashes allowed)", () => {
+    const dl = parseDeepLink("/gh/snomiao/codehost/tree/feat/x");
+    expect(dl?.type === "repo" && dl.target.branch).toBe("feat/x");
+  });
+
+  test("/git/<host>/owner/repo -> that host's key", () => {
+    const dl = parseDeepLink("/git/gitlab.com/group/proj/tree/dev");
+    expect(dl?.type).toBe("repo");
+    if (dl?.type === "repo") {
+      expect(repoKey(dl.target)).toBe("gitlab.com/group/proj");
+      expect(dl.target.branch).toBe("dev");
+    }
+  });
+
+  test("/dev/<path> -> dev target with leading slash", () => {
+    const dl = parseDeepLink("/dev/Users/sno/ws");
+    expect(dl?.type === "dev" && dl.target.path).toBe("/Users/sno/ws");
+  });
+
+  test("/dev/<Windows drive path> round-trips (colon in a non-leading segment)", () => {
+    // shareableDeepLink -> address bar -> parseDeepLink must preserve /C:/ws.
+    const path = shareableDeepLink({ folder: toPosixPath("C:\\ws") })!;
+    expect(path).toBe("/dev/C:/ws");
+    const dl = parseDeepLink(path);
+    expect(dl?.type === "dev" && dl.target.path).toBe("/C:/ws");
+  });
+
+  test("non-deep-link -> null", () => {
+    expect(parseDeepLink("/")).toBeNull();
+    expect(parseDeepLink("/settings")).toBeNull();
+  });
+});
+
+describe("shareableDeepLink", () => {
+  test("GitHub repo -> /gh sugar", () => {
+    expect(shareableDeepLink({ repo: "github.com/snomiao/codehost", branch: "main" })).toBe(
+      "/gh/snomiao/codehost/tree/main",
+    );
+    expect(shareableDeepLink({ repo: "github.com/snomiao/codehost" })).toBe("/gh/snomiao/codehost");
+  });
+
+  test("other host -> /git/<host>/...", () => {
+    expect(shareableDeepLink({ repo: "gitlab.com/group/proj", branch: "dev" })).toBe(
+      "/git/gitlab.com/group/proj/tree/dev",
+    );
+  });
+
+  test("no repo -> /dev/<folder> (Windows drive path preserved)", () => {
+    expect(shareableDeepLink({ folder: "/C:/ws" })).toBe("/dev/C:/ws");
+    expect(shareableDeepLink({ folder: "/Users/sno/ws" })).toBe("/dev/Users/sno/ws");
+  });
+
+  test("nothing addressable -> null", () => {
+    expect(shareableDeepLink({})).toBeNull();
+  });
+
+  test("round-trips: shareableDeepLink output parses back to the same key", () => {
+    const path = shareableDeepLink({ repo: "gitlab.com/group/proj", branch: "dev" })!;
+    const dl = parseDeepLink(path);
+    expect(dl?.type === "repo" && repoKey(dl.target)).toBe("gitlab.com/group/proj");
+  });
+});
+
+describe("pickRoomMatch (cross-room ranking)", () => {
+  const exact = { token: "tA", resolution: { peerId: "p1" } }; // no folder = exact
+  const root = { token: "tB", resolution: { peerId: "p2", folder: "/work/me/repo" } };
+
+  test("exact match (no folder) beats a root fallback, regardless of order", () => {
+    expect(pickRoomMatch([root, exact])?.token).toBe("tA");
+    expect(pickRoomMatch([exact, root])?.token).toBe("tA");
+  });
+
+  test("only root fallbacks -> first root", () => {
+    const root2 = { token: "tC", resolution: { peerId: "p3", folder: "/x" } };
+    expect(pickRoomMatch([root, root2])?.token).toBe("tB");
+  });
+
+  test("no matches -> null", () => {
+    expect(pickRoomMatch([])).toBeNull();
   });
 });

package/src/shared/repo.ts

@@ -1,13 +1,16 @@
-// Shared helpers for GitHub-shaped deep links and matching them to a daemon.
-// Used by the web resolver (src/web) and conceptually mirrors the daemon's
-// repo identity (src/cli/git.ts).
+// Shared helpers for git-shaped deep links and matching them to a daemon. Used
+// by the web resolver (src/web) and conceptually mirrors the daemon's repo
+// identity (src/cli/git.ts). Host-agnostic: GitHub gets the short `/gh/...`
+// form, any other host uses `/git/<host>/...`.
 
 import type { PeerInfo, PeerMeta } from "./signaling";
 
 export const DEFAULT_LAYOUT = "{owner}/{repo}/tree/{branch}";
+export const GITHUB_HOST = "github.com";
 
 export interface RepoTarget {
-  provider: "gh";
+  /** Git host, e.g. "github.com" or "gitlab.com". */
+  host: string;
   owner: string;
   name: string;
   /** Branch from the deep link, if present. */
@@ -26,10 +29,10 @@ export type DeepLink =
 
 /**
  * Parse a deep-link pathname:
- *   /gh/<owner>/<repo>                  -> repo target (default branch)
- *   /gh/<owner>/<repo>/tree/<branch>    -> repo target (branch; may contain slashes)
- *   /dev/<fs-path>                      -> direct folder mount
- * Anything else -> null (normal app).
+ *   /gh/<owner>/<repo>(/tree/<branch>)            -> GitHub repo target
+ *   /git/<host>/<owner>/<repo>(/tree/<branch>)    -> any-host repo target
+ *   /dev/<fs-path>                                -> direct folder mount
+ * Branch may contain slashes. Anything else -> null (normal app).
  */
 export function parseDeepLink(pathname: string): DeepLink {
   const clean = pathname.replace(/\/+$/, "");
@@ -37,7 +40,14 @@ export function parseDeepLink(pathname: string): DeepLink {
   if (gh) {
     return {
       type: "repo",
-      target: { provider: "gh", owner: gh[1], name: gh[2], branch: gh[3] },
+      target: { host: GITHUB_HOST, owner: gh[1], name: gh[2], branch: gh[3] },
+    };
+  }
+  const git = clean.match(/^\/git\/([^/]+)\/([^/]+)\/([^/]+)(?:\/tree\/(.+))?$/);
+  if (git) {
+    return {
+      type: "repo",
+      target: { host: git[1].toLowerCase(), owner: git[2], name: git[3], branch: git[4] },
     };
   }
   const dev = clean.match(/^\/dev\/(.+)$/);
@@ -47,25 +57,28 @@ export function parseDeepLink(pathname: string): DeepLink {
   return null;
 }
 
-/** Normalized repo key, e.g. "gh/owner/repo". */
-export function repoKey(t: Pick<RepoTarget, "owner" | "name">): string {
-  return `gh/${t.owner}/${t.name}`;
+/** Normalized repo key, e.g. "github.com/owner/repo" — matches PeerMeta.repo. */
+export function repoKey(t: Pick<RepoTarget, "host" | "owner" | "name">): string {
+  return `${t.host}/${t.owner}/${t.name}`;
 }
 
 /**
- * Normalize a served workspace path to the POSIX-drive form the browser side
- * and VS Code web expect. A Windows drive path becomes a `/c/...` style path
- * (lowercased drive, backslashes -> slashes): `C:\ws` -> `/c/ws`,
- * `C:\Users\x` -> `/c/Users/x`, `D:\` -> `/d`. POSIX absolute paths (mac/linux)
- * are returned unchanged. Used for `PeerMeta.cwd`, which feeds the `?folder=`
- * URI — the real OS path is still used for the local VS Code working dir.
+ * Normalize a served workspace path to the form VS Code web's `?folder=` query
+ * expects. On Windows that's the file-URI authority form: a leading slash, the
+ * drive letter and colon preserved, backslashes -> slashes —
+ * `C:\ws` -> `/C:/ws`, `C:\Users\x` -> `/C:/Users/x`, `D:\` -> `/D:`. (The
+ * git-bash `/c/ws` form does NOT resolve — serve-web reports "workspace does not
+ * exist".) POSIX absolute paths (mac/linux) are returned unchanged, and the
+ * result is idempotent. Used for `PeerMeta.cwd`, which feeds the `?folder=` URI
+ * (URL-encoded in transit, decoded back to this by VS Code) and the `/dev/<path>`
+ * deep link — the real OS path is still used for the local VS Code working dir.
  */
 export function toPosixPath(p: string): string {
   const drive = /^([A-Za-z]):(?:[\\/](.*))?$/.exec(p);
   if (drive) {
-    const letter = drive[1].toLowerCase();
+    const letter = drive[1]; // preserve drive-letter case
     const rest = (drive[2] ?? "").replace(/\\/g, "/").replace(/\/+$/, "");
-    return rest ? `/${letter}/${rest}` : `/${letter}`;
+    return rest ? `/${letter}:/${rest}` : `/${letter}:`;
   }
   // Already POSIX (or a relative path): just unify any stray backslashes.
   return p.replace(/\\/g, "/");
@@ -79,6 +92,26 @@ export function fillLayout(layout: string, t: RepoTarget): string {
     .replace(/\{branch\}/g, t.branch || "main");
 }
 
+/**
+ * Shareable deep-link pathname for a connected workspace. A git-identified
+ * server renders `/gh/<owner>/<repo>` for GitHub or `/git/<host>/<owner>/<repo>`
+ * for any other host (with `/tree/<branch>` when known); a non-git workspace is
+ * addressed by its opened folder as a `/dev/<path>` mount. Round-trips through
+ * parseDeepLink + resolve{Repo,Dev}Target so another room member opening it
+ * lands here. Returns null when there's nothing addressable.
+ */
+export function shareableDeepLink(opts: { repo?: string; branch?: string; folder?: string }): string | null {
+  if (opts.repo) {
+    const [host, owner, name] = opts.repo.split("/");
+    if (host && owner && name) {
+      const base = host === GITHUB_HOST ? `/gh/${owner}/${name}` : `/git/${host}/${owner}/${name}`;
+      return opts.branch ? `${base}/tree/${opts.branch}` : base;
+    }
+  }
+  if (opts.folder) return `/dev/${opts.folder.replace(/^\/+/, "")}`;
+  return null;
+}
+
 export interface Resolution {
   peerId: string;
   /** Folder to open via ?folder= (root kind); undefined opens the repo as-is. */
@@ -112,6 +145,24 @@ export function resolveDevTarget(servers: PeerInfo[], target: DevTarget): Resolu
   return hit ? { peerId: hit.peerId } : null;
 }
 
+/** A candidate room (its token) plus how the deep link resolved within it. */
+export interface RoomMatch {
+  token: string;
+  resolution: Resolution;
+}
+
+/**
+ * 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.
+ */
+export function pickRoomMatch(matches: RoomMatch[]): RoomMatch | null {
+  return matches.find((m) => !m.resolution.folder) ?? matches[0] ?? null;
+}
+
 function branchOk(meta: PeerMeta, target: RepoTarget): boolean {
   // No branch requested, or the server doesn't report one -> accept; else exact.
   if (!target.branch || !meta.branch) return true;

package/src/shared/signaling.ts

@@ -18,7 +18,7 @@ export interface PeerMeta {
    * Absent is treated as "repo" for backward compatibility.
    */
   kind?: "repo" | "root";
-  /** repo kind: normalized identity, e.g. "gh/snomiao/codehost". */
+  /** repo kind: host-agnostic identity, e.g. "github.com/snomiao/codehost". */
   repo?: string;
   /** repo kind: current branch, e.g. "main". */
   branch?: string;

package/src/web/discovery.tsx

@@ -9,12 +9,15 @@ import { registerTunnelHost } from "./tunnel-host";
 import { connBroker } from "./conn-broker";
 import {
   type DeepLink,
+  type RoomMatch,
   parseDeepLink,
+  pickRoomMatch,
   repoKey,
   resolveDevTarget,
   resolveRepoTarget,
+  shareableDeepLink,
 } from "../shared/repo";
-import { addRoom, historyFor, recordConnection } from "./history";
+import { addRoom, getRooms, historyFor, recordConnection } from "./history";
 
 const TOKEN_KEY = "codehost.token";
 
@@ -46,6 +49,50 @@ function folderQuery(folder?: string): string {
   return folder ? `?folder=${encodeURIComponent(folder)}` : "";
 }
 
+/**
+ * Find which of the user's saved rooms hosts a server matching a token-less deep
+ * link. Opens a short-lived viewer connection to each candidate room in
+ * parallel. An *exact* match (a server that truly serves this workspace) wins
+ * immediately; *root-fallback* matches (any room with a root daemon, which
+ * `resolveRepoTarget` returns for ANY repo link) are only chosen at the timeout,
+ * via `pickRoomMatch`, so an unrelated room with a root server can't steal the
+ * link. Resolves to the winning room's token (or null on no match). All temp
+ * clients are closed.
+ */
+function findRoomForDeepLink(dl: DeepLink, tokens: string[], timeoutMs = 6000): Promise<string | null> {
+  if (!dl || tokens.length === 0) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const clients: SignalingClient[] = [];
+    const fallbacks: RoomMatch[] = [];
+    let done = false;
+    const finish = (tok: string | null) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      clients.forEach((c) => c.close());
+      resolve(tok);
+    };
+    const timer = setTimeout(() => finish(pickRoomMatch(fallbacks)?.token ?? null), timeoutMs);
+    for (const tok of tokens) {
+      const client = new SignalingClient({
+        url: getSignalUrl(),
+        token: tok,
+        role: "viewer",
+        onPeers: (peers) => {
+          const servers = peers.filter((p) => p.role === "server");
+          const res =
+            dl.type === "repo" ? resolveRepoTarget(servers, dl.target) : resolveDevTarget(servers, dl.target);
+          if (!res) return;
+          if (!res.folder) finish(tok); // exact match — take it now
+          else if (!fallbacks.some((f) => f.token === tok)) fallbacks.push({ token: tok, resolution: res });
+        },
+      });
+      clients.push(client);
+      client.connect();
+    }
+  });
+}
+
 export function Discovery() {
   const [token, setToken] = useState(() => {
     const fromHash = tokenFromHash();
@@ -80,6 +127,11 @@ export function Discovery() {
   const activeFolderRef = useRef<string | undefined>(undefined);
   const [resolving, setResolving] = useState<string | null>(() => deepLinkLabel(deepLinkRef.current));
 
+  // Shareable deep-link pathname for the live connection (drives the address bar
+  // and the Share button); transient "copied" flag for the button.
+  const sharePathRef = useRef<string | null>(null);
+  const [copied, setCopied] = useState(false);
+
   // Register the Service Worker + connection broker once. The broker shares one
   // WebRTC connection per server across tabs; on owner failover it asks us to
   // reload the iframe so it reconnects through the new owner.
@@ -102,12 +154,22 @@ export function Discovery() {
       }
     }
 
-    // For a repo deep link, adopt the room that last served it so it resolves
-    // without re-entering a token.
+    // Resolve a token-less deep link to a room: first the room that last served
+    // this repo, otherwise search all saved rooms for a live server that hosts
+    // this workspace and adopt it. Skipped when the link already carries a token.
     const dl = deepLinkRef.current;
-    if (dl?.type === "repo") {
-      const h = historyFor(repoKey(dl.target));
-      if (h?.token) setToken(h.token);
+    if (dl && !(urlToken && validateToken(urlToken).ok)) {
+      const histToken = dl.type === "repo" ? historyFor(repoKey(dl.target))?.token : undefined;
+      if (histToken) {
+        setToken(histToken);
+      } else {
+        const rooms = getRooms();
+        if (rooms.length) {
+          void findRoomForDeepLink(dl, rooms).then((tok) => {
+            if (tok) setToken(tok);
+          });
+        }
+      }
     }
   }, []);
 
@@ -212,11 +274,37 @@ export function Discovery() {
       setIframeSrc(`/vs/${server.peerId}/${folderQuery(openFolder)}`);
       setResolving(null);
       recordConnect(server, openFolder);
+      updateAddressBar(server, openFolder);
     } catch {
       setConnState("failed");
     }
   }
 
+  // Reflect the live connection in the address bar as a clean, shareable deep
+  // link (no token — Share adds that). If we arrived via a deep link, keep its
+  // pathname; otherwise derive one from the server's repo identity or folder.
+  function updateAddressBar(server: PeerInfo, folder?: string) {
+    const path = deepLinkRef.current
+      ? window.location.pathname
+      : shareableDeepLink({ repo: server.meta?.repo, branch: server.meta?.branch, folder });
+    if (!path) return;
+    sharePathRef.current = path;
+    if (path !== window.location.pathname) history.replaceState(null, "", path);
+  }
+
+  async function shareLink() {
+    const path = sharePathRef.current ?? window.location.pathname;
+    const url = `${window.location.origin}${path}#t=${encodeURIComponent(token)}`;
+    try {
+      await navigator.clipboard.writeText(url);
+    } catch {
+      // clipboard blocked (insecure context / permission) — fall back to prompt
+      window.prompt("Copy this share link:", url);
+    }
+    setCopied(true);
+    setTimeout(() => setCopied(false), 1500);
+  }
+
   // Deep-link auto-connect: when servers arrive, pick the best match (exact repo
   // daemon, else a root daemon's subfolder) and open it once.
   async function tryAutoConnect(list: PeerInfo[]) {
@@ -261,6 +349,8 @@ export function Discovery() {
     setActivePeerId(null);
     activePeerRef.current = null;
     setConnState("idle");
+    sharePathRef.current = null;
+    if (window.location.pathname !== "/") history.replaceState(null, "", "/");
   }
 
   const activeServer = servers.find((s) => s.peerId === activePeerId);
@@ -275,6 +365,13 @@ export function Discovery() {
           <span style={styles.dim}>{activeServer?.meta?.name ?? activePeerId?.slice(0, 8)}</span>
           {activeServer?.meta?.cwd && <span style={styles.cwd}>{activeServer.meta.cwd}</span>}
           <span style={{ flex: 1 }} />
+          <button
+            style={styles.shareBtn}
+            onClick={shareLink}
+            title="Copy a link that opens this workspace (includes the room token)"
+          >
+            {copied ? "Copied!" : "Share"}
+          </button>
           <button style={styles.connectBtn} onClick={disconnect}>
             Disconnect
           </button>
@@ -389,4 +486,5 @@ const styles: Record<string, React.CSSProperties> = {
   cwd: { fontFamily: "monospace" },
   echo: { marginTop: 6, fontSize: 12, color: "#4ec9b0", fontFamily: "monospace" },
   connectBtn: { background: "#0e639c", border: "none", color: "#fff", padding: "6px 14px", borderRadius: 6, cursor: "pointer", fontSize: 13 },
+  shareBtn: { background: "transparent", border: "1px solid #3d3d3d", color: "#ccc", padding: "6px 14px", borderRadius: 6, cursor: "pointer", fontSize: 13 },
 };