codehost 0.3.1 → 0.5.0

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+# [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)
+
+
+### Bug Fixes
+
+* normalize Windows serve path to POSIX-drive form for VS Code web ([8add2d6](https://github.com/snomiao/codehost/commit/8add2d66a6b5ae765f91386f738ad38abcb90057))
+
+
+### Features
+
+* setup.sh/ps1 installer aliases + self-update to latest on serve/setup ([93a5d64](https://github.com/snomiao/codehost/commit/93a5d64170c5851ca0f488348975dae46f467b5e))
+
 ## [0.3.1](https://github.com/snomiao/codehost/compare/v0.3.0...v0.3.1) (2026-06-07)
 
 

package/README.md

@@ -32,6 +32,11 @@ curl -fsSL https://codehost.dev/install.sh | sh
 powershell -c "irm codehost.dev/install.ps1 | iex"
 ```
 
+`/setup.sh` and `/setup.ps1` are aliases of the same script. Re-running it any
+time **upgrades you to the latest codehost** (`bun add -g codehost@latest`), so
+it doubles as the updater — and it bootstraps Bun by absolute path, so it won't
+bail just because your shell hasn't picked Bun up on `PATH` yet.
+
 Already have Bun? `bun add -g codehost && codehost setup` does the same. Or, for
 a specific directory/token in one shot:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
     "deploy:signal": "cd worker && wrangler deploy",
     "deploy:pages": "vite build && wrangler pages deploy dist/public --project-name codehost",
     "start": "bun src/server.ts",
+    "test": "bun test",
     "typecheck": "tsc --noEmit && tsc --noEmit -p src/web/tsconfig.sw.json && tsc --noEmit -p worker/tsconfig.json"
   },
   "dependencies": {

package/public/_redirects

@@ -1,3 +1,8 @@
+# Friendly aliases for the installer: /setup.sh and /setup.ps1 serve the same
+# scripts as /install.*. Must precede the SPA catch-all below (first match wins).
+/setup.sh   /install.sh   200
+/setup.ps1  /install.ps1  200
+
 # SPA fallback: deep links like /gh/<owner>/<repo>/tree/<branch> and /dev/<path>
 # have no static file, so serve the app and let it route client-side. Cloudflare
 # Pages serves existing files first (/assets/*, /sw.js, /install.*), so only

package/public/install.ps1

@@ -1,12 +1,19 @@
-# codehost installer — https://codehost.dev
+# codehost installer / updater — https://codehost.dev
 #
 #   powershell -c "irm codehost.dev/install.ps1 | iex"
+#   powershell -c "irm codehost.dev/setup.ps1   | iex"   # same script, friendlier name
 #
-# Ensures Bun is installed, installs the `codehost` CLI globally (which fetches
-# the native WebRTC binary via Bun's lifecycle scripts), then runs `codehost
-# setup` to pick a token, install VS Code, and start a server daemon.
+# Ensures Bun is installed, installs/UPGRADES the `codehost` CLI globally to the
+# latest release (which fetches the native WebRTC binary via Bun's lifecycle
+# scripts), then runs `codehost setup` to pick a token, install VS Code, and
+# start a server daemon. Safe to re-run any time — it always lands you on the
+# newest codehost.
 #
-# Env override: $env:CODEHOST_NO_SETUP = "1"  -> install only, skip setup.
+# Bun is the runtime and can't be skipped — we bootstrap it and then invoke
+# everything by absolute path, so a not-yet-reloaded shell PATH never makes the
+# install "fail" after Bun is actually present.
+#
+# Env override: $env:CODEHOST_NO_SETUP = "1"  -> install/update only, skip setup.
 
 $ErrorActionPreference = "Stop"
 
@@ -15,29 +22,38 @@ function Fail($m) { Write-Host "[codehost] $m" -ForegroundColor Red; exit 1 }
 
 # Bun installs its global bin under %USERPROFILE%\.bun\bin by default.
 $bunBin = Join-Path $env:USERPROFILE ".bun\bin"
+$bunExe = Join-Path $bunBin "bun.exe"
 if (Test-Path $bunBin) { $env:Path = "$bunBin;$env:Path" }
 
-if (-not (Get-Command bun -ErrorAction SilentlyContinue)) {
+if (-not (Test-Path $bunExe)) {
   Info "Bun not found - installing from bun.sh..."
   Invoke-RestMethod https://bun.sh/install.ps1 | Invoke-Expression
   if (Test-Path $bunBin) { $env:Path = "$bunBin;$env:Path" }
 }
 
-if (-not (Get-Command bun -ErrorAction SilentlyContinue)) {
-  Fail "Bun install did not land on PATH. Open a new terminal and re-run."
+# Prefer the absolute path; fall back to a PATH lookup in case Bun honored a
+# custom install dir. Either way we never bail just because PATH wasn't reloaded.
+if (-not (Test-Path $bunExe)) {
+  $cmd = Get-Command bun -ErrorAction SilentlyContinue
+  if ($cmd) { $bunExe = $cmd.Source }
+  else { Fail "Bun was installed but bun.exe wasn't found at $bunBin. Open a new terminal and re-run." }
 }
 
-Info "installing the codehost CLI (bun add -g codehost)..."
-bun add -g codehost
+# `@latest` makes every re-run an upgrade, so users always end up on the newest
+# codehost instead of a stale globally-pinned copy.
+Info "installing the latest codehost CLI (bun add -g codehost@latest)..."
+& $bunExe add -g codehost@latest
 
-if (-not (Get-Command codehost -ErrorAction SilentlyContinue)) {
-  Fail "codehost installed but not on PATH. Add $bunBin to PATH and run: codehost setup"
-}
+# Resolve the codehost shim Bun just wrote (extension varies on Windows).
+$codehostCmd = Get-Command codehost -ErrorAction SilentlyContinue
+if ($codehostCmd) { $codehostExe = $codehostCmd.Source }
+elseif (Test-Path (Join-Path $bunBin "codehost.exe")) { $codehostExe = Join-Path $bunBin "codehost.exe" }
+else { Fail "codehost installed but not found in $bunBin. Add it to PATH and run: codehost setup" }
 
 if ($env:CODEHOST_NO_SETUP -eq "1") {
-  Info "installed. Run ``codehost setup`` in the directory you want to serve."
+  Info "installed/updated. Run ``codehost setup`` in the directory you want to serve."
   exit 0
 }
 
 Info "running ``codehost setup``..."
-codehost setup
+& $codehostExe setup

package/public/install.sh

@@ -1,14 +1,22 @@
 #!/bin/sh
-# codehost installer — https://codehost.dev
+# codehost installer / updater — https://codehost.dev
 #
 #   curl -fsSL https://codehost.dev/install.sh | sh
+#   curl -fsSL https://codehost.dev/setup.sh   | sh   # same script, friendlier name
 #
-# Ensures Bun is installed, installs the `codehost` CLI globally (which fetches
-# the native WebRTC binary via Bun's lifecycle scripts), then runs `codehost
-# setup` to pick a token, install VS Code, and start a server daemon.
+# Ensures Bun is installed, installs/UPGRADES the `codehost` CLI globally to the
+# latest release (which fetches the native WebRTC binary via Bun's lifecycle
+# scripts), then runs `codehost setup` to pick a token, install VS Code, and
+# start a server daemon. Safe to re-run any time — it always lands you on the
+# newest codehost.
+#
+# Bun is the runtime (the CLI is TypeScript run by Bun + a native addon), so it
+# can't be skipped — but we bootstrap it and then invoke everything by absolute
+# path, so a not-yet-reloaded shell PATH never makes the install "fail" after
+# Bun is actually present.
 #
 # Env overrides:
-#   CODEHOST_NO_SETUP=1   install only; don't run `codehost setup`
+#   CODEHOST_NO_SETUP=1   install/update only; don't run `codehost setup`
 set -eu
 
 info() { printf '\033[1;36m[codehost]\033[0m %s\n' "$1"; }
@@ -20,7 +28,18 @@ BUN_INSTALL="${BUN_INSTALL:-$HOME/.bun}"
 export BUN_INSTALL
 export PATH="$BUN_INSTALL/bin:$PATH"
 
-if ! command -v bun >/dev/null 2>&1; then
+# Resolve a usable bun binary: one already on PATH, or the managed install.
+# Echoes the absolute path (empty if none) so callers can invoke it directly.
+bun_bin() {
+  if command -v bun >/dev/null 2>&1; then
+    command -v bun
+  elif [ -x "$BUN_INSTALL/bin/bun" ]; then
+    printf '%s\n' "$BUN_INSTALL/bin/bun"
+  fi
+}
+
+BUN="$(bun_bin)"
+if [ -z "$BUN" ]; then
   info "Bun not found — installing from bun.sh…"
   if command -v curl >/dev/null 2>&1; then
     curl -fsSL https://bun.sh/install | bash
@@ -30,26 +49,32 @@ if ! command -v bun >/dev/null 2>&1; then
     err "need curl or wget to install Bun. Install one and re-run."
     exit 1
   fi
-  export PATH="$BUN_INSTALL/bin:$PATH"
+  BUN="$(bun_bin)"
 fi
 
-if ! command -v bun >/dev/null 2>&1; then
-  err "Bun install did not land on PATH. Open a new shell or add $BUN_INSTALL/bin to PATH, then re-run."
+if [ -z "$BUN" ]; then
+  err "Bun was installed but its binary isn't at $BUN_INSTALL/bin/bun. Set BUN_INSTALL to its location and re-run."
   exit 1
 fi
 
-info "installing the codehost CLI (bun add -g codehost)…"
-bun add -g codehost
+# `@latest` makes every re-run an upgrade, so users always end up on the newest
+# codehost instead of a stale globally-pinned copy.
+info "installing the latest codehost CLI ($BUN add -g codehost@latest)…"
+"$BUN" add -g codehost@latest
 
-if ! command -v codehost >/dev/null 2>&1; then
-  err "codehost installed but not on PATH. Add $BUN_INSTALL/bin to your PATH and run: codehost setup"
+CODEHOST="$BUN_INSTALL/bin/codehost"
+if [ ! -x "$CODEHOST" ]; then
+  CODEHOST="$(command -v codehost || true)"
+fi
+if [ -z "$CODEHOST" ] || [ ! -x "$CODEHOST" ]; then
+  err "codehost installed but not found under $BUN_INSTALL/bin. Add it to PATH and run: codehost setup"
   exit 1
 fi
 
 if [ "${CODEHOST_NO_SETUP:-}" = "1" ]; then
-  info "installed. Run \`codehost setup\` in the directory you want to serve."
+  info "installed/updated. Run \`codehost setup\` in the directory you want to serve."
   exit 0
 fi
 
 info "running \`codehost setup\`…"
-exec codehost setup
+exec "$CODEHOST" setup

package/src/cli/commands/dev.ts

@@ -8,6 +8,7 @@ import { announceConnect } from "../open-url";
 import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
 import { repoIdentity } from "../git";
+import { toPosixPath } from "../../shared/repo";
 import { DEFAULT_SIGNAL_URL } from "./serve";
 
 interface DevArgs {
@@ -22,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", {
@@ -85,7 +86,9 @@ export const devCommand: CommandModule<{}, DevArgs> = {
     const id = repoIdentity(dir);
     const meta: PeerMeta = {
       name: argv.name ?? host,
-      cwd: dir,
+      // POSIX-drive 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",
       repo: id.repo,

package/src/cli/commands/serve.ts

@@ -2,7 +2,7 @@ import { hostname } from "node:os";
 import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
-import { DEFAULT_LAYOUT } from "../../shared/repo";
+import { DEFAULT_LAYOUT, toPosixPath } from "../../shared/repo";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
 import { launchServeDaemon } from "../daemonize";
 import { announceConnect } from "../open-url";
@@ -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,9 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     // onto subfolders via VS Code's ?folder= using this layout.
     const meta: PeerMeta = {
       name: argv.name ?? host,
-      cwd: dir,
+      // POSIX-drive form for the browser ?folder= URI (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,

package/src/cli/daemonize.ts

@@ -1,4 +1,5 @@
 import { daemonName, startDaemon } from "./oxmgr";
+import { selfUpdate } from "./self-update";
 
 export interface ServeDaemonOptions {
   /** Subcommand to re-launch under oxmgr. */
@@ -31,6 +32,11 @@ export interface ServeDaemonResult {
  * the shell and restarts on failure. Shared by `serve -d` and `setup`.
  */
 export async function launchServeDaemon(opts: ServeDaemonOptions): Promise<ServeDaemonResult> {
+  // Upgrade the global install (if that's how we're running) before spawning, so
+  // the fresh daemon runs the latest code. startDaemon does delete+start, so a
+  // re-launch replaces any live daemon with the updated one. Non-fatal.
+  await selfUpdate();
+
   const label = opts.name ?? opts.dir.split("/").pop() ?? opts.host;
   const name = daemonName(label);
   const command = buildForegroundCommand(opts);

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/self-update.ts

@@ -0,0 +1,89 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Best-effort self-update, run right before a daemon is (re)spawned (see the top
+// of launchServeDaemon). Re-launching `setup` or `serve -d` replaces the managed
+// daemon (oxmgr delete + start), so upgrading the global package here means the
+// fresh daemon process runs the new code — there's no in-place restart, so this
+// never trips oxmgr's `on-failure` policy and never drops a live session
+// mid-flight. A days-old daemon only updates on the next launcher run.
+
+const REGISTRY_LATEST = "https://registry.npmjs.org/codehost/latest";
+const FETCH_TIMEOUT_MS = 5_000;
+const INSTALL_TIMEOUT_MS = 120_000;
+
+/**
+ * Upgrade the global `codehost` to the latest published version if we're running
+ * from a real global install (`bun add -g` / `npm i -g`). A dev checkout or a
+ * `bunx` run is left untouched so we never clobber the user's global copy.
+ *
+ * Fully non-fatal: an offline registry, a slow network, or a failed `bun add`
+ * must never stop the server from launching — every failure path just logs and
+ * returns. Disable entirely with CODEHOST_NO_SELF_UPDATE=1.
+ */
+export async function selfUpdate(): Promise<void> {
+  if (process.env.CODEHOST_NO_SELF_UPDATE === "1") return;
+  try {
+    if (!isGlobalInstall()) return; // dev checkout or bunx: don't touch the global
+
+    const installed = currentVersion();
+    if (!installed) return; // can't locate our own package.json — don't risk it
+
+    const latest = await fetchLatest();
+    if (!latest || latest === installed) return;
+
+    console.log(`[codehost] updating codehost ${installed} → ${latest}…`);
+    const r = spawnSync(process.execPath, ["add", "-g", `codehost@${latest}`], {
+      stdio: "inherit",
+      timeout: INSTALL_TIMEOUT_MS,
+    });
+    if (r.status === 0) {
+      console.log(`[codehost] updated to ${latest}; the new daemon will run it.`);
+    } else {
+      console.warn(`[codehost] self-update to ${latest} failed; continuing on ${installed}.`);
+    }
+  } catch (err) {
+    console.warn(`[codehost] self-update skipped: ${(err as Error).message}`);
+  }
+}
+
+/** Version from our own package.json (src/cli → package root is two up). */
+function currentVersion(): string | null {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8"),
+    ) as { version?: unknown };
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * True only when this file lives in a well-known *global* package directory we
+ * own. Conservative on purpose: anything unrecognized (dev repo, bunx cache,
+ * unusual layout) returns false so we skip rather than risk overwriting the
+ * wrong tree.
+ */
+function isGlobalInstall(): boolean {
+  const dir = import.meta.dir.replace(/\\/g, "/");
+  return (
+    dir.includes("/.bun/install/global/node_modules/codehost/") || // bun add -g
+    dir.includes("/lib/node_modules/codehost/") // npm i -g (unix default prefix)
+  );
+}
+
+/** Latest published version per the npm registry, or null on any failure. */
+async function fetchLatest(): Promise<string | null> {
+  try {
+    const res = await fetch(REGISTRY_LATEST, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { version?: unknown };
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}

package/src/shared/repo.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, test } from "bun:test";
+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");
+  });
+
+  test("lowercases the drive letter", () => {
+    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("forward-slash Windows paths normalize too", () => {
+    expect(toPosixPath("C:/ws")).toBe("/c/ws");
+  });
+
+  test("POSIX absolute paths are unchanged (mac/linux not broken)", () => {
+    expect(toPosixPath("/Users/sno/ws")).toBe("/Users/sno/ws");
+    expect(toPosixPath("/home/x/proj")).toBe("/home/x/proj");
+    expect(toPosixPath("/")).toBe("/");
+  });
+
+  test("already-normalized POSIX-drive path is a no-op", () => {
+    expect(toPosixPath("/c/ws")).toBe("/c/ws");
+  });
+
+  test("trims trailing backslashes/slashes on a drive path", () => {
+    expect(toPosixPath("C:\\ws\\")).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/c/ws");
+    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>", () => {
+    expect(shareableDeepLink({ folder: "/c/ws" })).toBe("/dev/c/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,9 +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.
+ */
+export function toPosixPath(p: string): string {
+  const drive = /^([A-Za-z]):(?:[\\/](.*))?$/.exec(p);
+  if (drive) {
+    const letter = drive[1].toLowerCase();
+    const rest = (drive[2] ?? "").replace(/\\/g, "/").replace(/\/+$/, "");
+    return rest ? `/${letter}/${rest}` : `/${letter}`;
+  }
+  // Already POSIX (or a relative path): just unify any stray backslashes.
+  return p.replace(/\\/g, "/");
 }
 
 /** Fill a layout template from a repo target (default branch -> "main"). */
@@ -60,6 +89,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. */
@@ -93,6 +142,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 },
 };