codehost 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.14.0](https://github.com/snomiao/codehost/compare/v0.13.0...v0.14.0) (2026-06-10)
+
+
+### Features
+
+* **web:** always show /tree/<branch> for repo workspaces ([ad34bc2](https://github.com/snomiao/codehost/commit/ad34bc2e2e8acea98ac392b90766488c6f3b4e52))
+
+# [0.13.0](https://github.com/snomiao/codehost/compare/v0.12.0...v0.13.0) (2026-06-09)
+
+
+### Features
+
+* **web:** host-scoped folder deep links — /host/<hostname>/<path> ([f6955ab](https://github.com/snomiao/codehost/commit/f6955ab37517f312ee780795efc503cb74ccdc36))
+
 # [0.12.0](https://github.com/snomiao/codehost/compare/v0.11.1...v0.12.0) (2026-06-09)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "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>, /git/<host>/<owner>/<repo> for a git repo)",
+    "Serve a single folder over WebRTC; open it at codehost.dev/host/<hostname>/<path> (or /gh/<owner>/<repo>, /git/<host>/<owner>/<repo> for a git repo)",
   builder: (y) =>
     y
       .positional("dir", {

package/src/shared/repo.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { parseDeepLink, pickRoomMatch, repoKey, shareableDeepLink, toPosixPath } from "./repo";
+import { parseDeepLink, pickRoomMatch, repoKey, resolveDevTarget, shareableDeepLink, toPosixPath } from "./repo";
+import type { PeerInfo } from "./signaling";
 import { parseGitRemote } from "../cli/git";
 
 describe("toPosixPath", () => {
@@ -109,12 +110,60 @@ describe("parseDeepLink + repoKey round-trip", () => {
     expect(dl?.type === "dev" && dl.target.path).toBe("/C:/ws");
   });
 
+  test("/host/<hostname>/<path> -> host-scoped dev target", () => {
+    const dl = parseDeepLink("/host/Mac/Users/taku");
+    expect(dl?.type === "dev" && dl.target.host).toBe("Mac");
+    expect(dl?.type === "dev" && dl.target.path).toBe("/Users/taku");
+  });
+
+  test("/host/<hostname>/<Windows drive path> round-trips", () => {
+    const path = shareableDeepLink({ folder: "/C:/ws", host: "EC2AMAZ-PH8C4K1" })!;
+    expect(path).toBe("/host/EC2AMAZ-PH8C4K1/C:/ws");
+    const dl = parseDeepLink(path);
+    expect(dl?.type === "dev" && dl.target.host).toBe("EC2AMAZ-PH8C4K1");
+    expect(dl?.type === "dev" && dl.target.path).toBe("/C:/ws");
+  });
+
+  test("legacy /dev/<path> still parses host-agnostic (no host)", () => {
+    const dl = parseDeepLink("/dev/C:/ws");
+    expect(dl?.type === "dev" && dl.target.host).toBeUndefined();
+    expect(dl?.type === "dev" && dl.target.path).toBe("/C:/ws");
+  });
+
   test("non-deep-link -> null", () => {
     expect(parseDeepLink("/")).toBeNull();
     expect(parseDeepLink("/settings")).toBeNull();
   });
 });
 
+describe("resolveDevTarget host scoping", () => {
+  const mk = (peerId: string, host: string, cwd: string): PeerInfo => ({
+    peerId,
+    role: "server",
+    meta: { name: host, host, cwd },
+  });
+  // Same served path on two different machines — the ambiguity host scoping fixes.
+  const servers = [mk("pA", "boxA", "/C:/ws"), mk("pB", "boxB", "/C:/ws")];
+
+  test("host-scoped target picks the matching host", () => {
+    expect(resolveDevTarget(servers, { host: "boxB", path: "/C:/ws" })?.peerId).toBe("pB");
+    expect(resolveDevTarget(servers, { host: "boxA", path: "/C:/ws" })?.peerId).toBe("pA");
+  });
+
+  test("host-scoped target with no matching host -> null (won't cross machines)", () => {
+    expect(resolveDevTarget(servers, { host: "boxC", path: "/C:/ws" })).toBeNull();
+  });
+
+  test("legacy host-agnostic target matches by path alone", () => {
+    expect(resolveDevTarget(servers, { path: "/C:/ws" })?.peerId).toBe("pA");
+  });
+
+  test("leading/trailing slash differences still match (e.g. expose cwd)", () => {
+    const ex = [mk("pE", "boxE", "localhost:8090")];
+    expect(resolveDevTarget(ex, { host: "boxE", path: "/localhost:8090" })?.peerId).toBe("pE");
+  });
+});
+
 describe("shareableDeepLink", () => {
   test("GitHub repo -> /gh sugar", () => {
     expect(shareableDeepLink({ repo: "github.com/snomiao/codehost", branch: "main" })).toBe(

package/src/shared/repo.ts

@@ -7,6 +7,10 @@ import type { PeerInfo, PeerMeta } from "./signaling";
 
 export const DEFAULT_LAYOUT = "{owner}/{repo}/tree/{branch}";
 export const GITHUB_HOST = "github.com";
+/** Branch assumed when a repo link/target carries none — what `fillLayout` opens
+ *  and what the address bar shows, so a bare `/gh/<owner>/<repo>` canonicalizes
+ *  to `/gh/<owner>/<repo>/tree/<DEFAULT_BRANCH>`. */
+export const DEFAULT_BRANCH = "main";
 
 export interface RepoTarget {
   /** Git host, e.g. "github.com" or "gitlab.com". */
@@ -17,8 +21,12 @@ export interface RepoTarget {
   branch?: string;
 }
 
-/** A direct folder mount address: `/dev/<absolute-fs-path>`. */
+/** A direct folder mount address: host-scoped `/host/<hostname>/<path>`, or the
+ *  legacy host-agnostic `/dev/<path>` (a bare path collides across machines, so
+ *  new links carry the host). */
 export interface DevTarget {
+  /** Hostname the workspace lives on; undefined for a legacy host-agnostic link. */
+  host?: string;
   path: string;
 }
 
@@ -31,7 +39,8 @@ export type DeepLink =
  * Parse a deep-link pathname:
  *   /gh/<owner>/<repo>(/tree/<branch>)            -> GitHub repo target
  *   /git/<host>/<owner>/<repo>(/tree/<branch>)    -> any-host repo target
- *   /dev/<fs-path>                                -> direct folder mount
+ *   /host/<hostname>/<fs-path>                    -> host-scoped folder mount
+ *   /dev/<fs-path>                                -> legacy host-agnostic folder mount
  * Branch may contain slashes. Anything else -> null (normal app).
  */
 export function parseDeepLink(pathname: string): DeepLink {
@@ -50,6 +59,13 @@ export function parseDeepLink(pathname: string): DeepLink {
       target: { host: git[1].toLowerCase(), owner: git[2], name: git[3], branch: git[4] },
     };
   }
+  // Host-scoped folder mount: first segment is the hostname, the rest is the
+  // served path (which itself may contain slashes and a Windows drive colon).
+  const host = clean.match(/^\/host\/([^/]+)\/(.+)$/);
+  if (host) {
+    return { type: "dev", target: { host: host[1], path: `/${host[2].replace(/^\/+/, "")}` } };
+  }
+  // Legacy host-agnostic folder mount.
   const dev = clean.match(/^\/dev\/(.+)$/);
   if (dev) {
     return { type: "dev", target: { path: `/${dev[1].replace(/^\/+/, "")}` } };
@@ -84,23 +100,29 @@ export function toPosixPath(p: string): string {
   return p.replace(/\\/g, "/");
 }
 
-/** Fill a layout template from a repo target (default branch -> "main"). */
+/** Fill a layout template from a repo target (default branch -> DEFAULT_BRANCH). */
 export function fillLayout(layout: string, t: RepoTarget): string {
   return layout
     .replace(/\{owner\}/g, t.owner)
     .replace(/\{repo\}/g, t.name)
-    .replace(/\{branch\}/g, t.branch || "main");
+    .replace(/\{branch\}/g, t.branch || DEFAULT_BRANCH);
 }
 
 /**
  * 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
+ * addressed by its opened folder, scoped to its hostname as `/host/<host>/<path>`
+ * (or the legacy `/dev/<path>` when no host is known). 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 {
+export function shareableDeepLink(opts: {
+  repo?: string;
+  branch?: string;
+  folder?: string;
+  host?: string;
+}): string | null {
   if (opts.repo) {
     const [host, owner, name] = opts.repo.split("/");
     if (host && owner && name) {
@@ -108,7 +130,10 @@ export function shareableDeepLink(opts: { repo?: string; branch?: string; folder
       return opts.branch ? `${base}/tree/${opts.branch}` : base;
     }
   }
-  if (opts.folder) return `/dev/${opts.folder.replace(/^\/+/, "")}`;
+  if (opts.folder) {
+    const path = opts.folder.replace(/^\/+/, "");
+    return opts.host ? `/host/${opts.host}/${path}` : `/dev/${path}`;
+  }
   return null;
 }
 
@@ -138,13 +163,16 @@ export function resolveRepoTarget(servers: PeerInfo[], target: RepoTarget): Reso
   return null;
 }
 
-/** Pick a `dev`/repo server whose served cwd matches a /dev/<path> target.
- *  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 would never match it. */
+/** Pick a folder-mount server whose served cwd matches the target path, scoped
+ *  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. */
 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);
+  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;
 }
 

package/src/web/discovery.tsx

@@ -8,6 +8,7 @@ import { getSignalUrl } from "./config";
 import { registerTunnelHost } from "./tunnel-host";
 import { connBroker } from "./conn-broker";
 import {
+  DEFAULT_BRANCH,
   type DeepLink,
   type RoomMatch,
   parseDeepLink,
@@ -46,7 +47,8 @@ function tokenFromHash(): string {
 /** Short label for the "looking for…" state from a deep link. */
 function deepLinkLabel(dl: DeepLink): string | null {
   if (!dl) return null;
-  return dl.type === "repo" ? `${dl.target.owner}/${dl.target.name}` : dl.target.path;
+  if (dl.type === "repo") return `${dl.target.owner}/${dl.target.name}`;
+  return dl.target.host ? `${dl.target.host}:${dl.target.path}` : dl.target.path;
 }
 
 function folderQuery(folder?: string): string {
@@ -355,10 +357,19 @@ export function Discovery() {
         sharePathRef.current = window.location.pathname;
       } else {
         const targetPath = shareablePathFor(server, openFolder);
-        didPush = !!targetPath && targetPath !== window.location.pathname;
-        if (didPush) history.pushState(null, "", targetPath);
-        pushedRef.current = didPush;
         sharePathRef.current = targetPath ?? window.location.pathname;
+        if (targetPath && targetPath !== window.location.pathname) {
+          if (deepLinkRef.current) {
+            // Arrived via a deep link — canonicalize the URL in place (e.g. add
+            // /tree/<branch>). Same destination, so replace, don't push a
+            // back-to-the-list entry.
+            history.replaceState(null, "", targetPath);
+          } else {
+            history.pushState(null, "", targetPath);
+            didPush = true;
+          }
+        }
+        pushedRef.current = didPush;
       }
 
       // The broker decides whether this tab owns the connection. `establish` is
@@ -416,9 +427,20 @@ export function Discovery() {
   // token — Share adds that). Keeps an existing deep-link path as-is; otherwise
   // derives /gh|/git|/dev from the server's repo identity or opened folder.
   function shareablePathFor(server: PeerInfo, folder?: string): string | null {
-    return deepLinkRef.current
-      ? window.location.pathname
-      : shareableDeepLink({ repo: server.meta?.repo, branch: server.meta?.branch, folder });
+    const dl = deepLinkRef.current;
+    // A repo workspace always shows /tree/<branch> (GitHub-style, and it pins the
+    // worktree in snomiao's /tree/<branch> layout). Branch source, in order: the
+    // deep link's branch, the server's reported branch, else the layout default —
+    // matching the worktree fillLayout actually opened.
+    if (dl?.type === "repo") {
+      const branch = dl.target.branch ?? server.meta?.branch ?? DEFAULT_BRANCH;
+      return shareableDeepLink({ repo: repoKey(dl.target), branch });
+    }
+    if (server.meta?.repo) {
+      return shareableDeepLink({ repo: server.meta.repo, branch: server.meta.branch ?? DEFAULT_BRANCH });
+    }
+    // Folder mount: keep the deep-link path as-is, else derive the host-scoped one.
+    return dl ? window.location.pathname : shareableDeepLink({ folder, host: server.meta?.host });
   }
 
   async function shareLink() {