codehost 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.15.0](https://github.com/snomiao/codehost/compare/v0.14.0...v0.15.0) (2026-06-10)
+
+
+### Features
+
+* **web:** 'open a GitHub URL' box + deepest-root repo resolution ([0d9ebec](https://github.com/snomiao/codehost/commit/0d9ebec4409430c327e2945657b6803ca704fd53))
+
+# [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)
 
 

package/docs/provisioning.md

@@ -0,0 +1,130 @@
+# Workspace provisioning
+
+Status: **design / proposal** (not implemented). Captures the design discussed
+for "open a repo link → the workspace materializes on the host".
+
+## Goal
+
+Opening a repo deep link should *materialize* the workspace on the serving host
+on demand — clone / worktree-add / install — instead of requiring it to already
+exist. Today, opening `/gh/<owner>/<repo>/tree/<branch>` when that worktree isn't
+present just fails (`serve-web` reports "workspace does not exist").
+
+The host owner stays in control: all provisioning is a **user-authored,
+idempotent script** on the host. codehost never invents commands.
+
+## Model
+
+`codehost serve` runs in a *home* directory (`$HOME_ROOT`):
+
+```
+$HOME_ROOT/
+├── .codehost/                  # config dir — edited in VS Code itself
+│   ├── config.yaml             # settings (workspace path template, allowlist…)
+│   ├── setup.sh / setup.bat    # idempotent provisioning, run on every open
+│   └── …                       # any other files the user keeps here
+└── ws/                         # default workspaces root (redefinable in config.yaml)
+    └── <owner>/<repo>/tree/<branch>/
+```
+
+- `.codehost/` is the config folder. `ws/` is where github-shaped paths land.
+- Default layout: `ws/{owner}/{repo}/tree/{branch}` (the `tree/<branch>` worktree
+  convention — branches are real side-by-side directories).
+- The workspace path is redefinable in `config.yaml`.
+
+## Open flow
+
+```
+open /gh/<owner>/<repo>/tree/<branch>
+  → daemon runs .codehost/setup.sh with owner/repo/branch (+ host)
+       setup.sh decides: clone / git worktree add / pull / rebase / skip
+       (idempotent — the policy, incl. auto-upgrade/rebase, is the user's)
+  → VS Code opens the resulting workspace path
+```
+
+Because `setup.sh` is idempotent and runs **every** time, codehost does not track
+clone state at all — the script clones if missing, fast-skips if present, and the
+user decides whether to auto-pull/rebase. This removes a lot of codehost logic.
+
+## `setup.sh` contract
+
+- **Input** (env, never interpolated into a command string):
+  `CODEHOST_OWNER`, `CODEHOST_REPO`, `CODEHOST_BRANCH`, `CODEHOST_HOST`,
+  `CODEHOST_HOME` (the home root), `CODEHOST_WS` (the resolved default path from
+  the `config.yaml` template).
+- **Output**: the absolute workspace path on stdout (last line). If it prints
+  nothing, codehost uses `CODEHOST_WS` (the template default).
+- **Exit non-zero** → provisioning failed; surface the error to the browser.
+- Must be **idempotent** and fast on an already-provisioned path (skip).
+- **Windows**: `setup.bat` (or pwsh) with the same env contract.
+
+## `config.yaml` (sketch)
+
+```yaml
+workspace: "ws/{owner}/{repo}/tree/{branch}"   # path template, relative to home
+allowlist:                                      # which repos may auto-provision
+  - github.com/snomiao/*
+# …future: default branch, install hook, etc.
+```
+
+## Reuse VS Code for config (no custom UI)
+
+Editing config = open `$HOME_ROOT/.codehost/` in the **existing VS Code iframe**.
+A "Config" affordance in the header opens `?folder=<home>/.codehost`. No
+`/p/<peer-id>/` settings page, no re-invented editor. (Peer ids are ephemeral —
+they change on every daemon restart — so config is keyed by the host/home, not
+the peer.)
+
+## Create-from-GitHub input box
+
+On the workspace list page, an input: **paste a GitHub URL**.
+
+```
+https://github.com/snomiao/codehost/tree/main
+  → parse → /gh/snomiao/codehost/tree/main → open (triggers provisioning)
+```
+
+One paste opens any GitHub repo on a connected host (= "create workspace from
+GitHub"). Accepts bare `github.com/<owner>/<repo>` and `…/tree/<branch>` forms.
+
+## Provisioning UX
+
+- While `setup.sh` runs, show a **"provisioning…"** state with the script's
+  stdout/stderr **streamed over the tunnel** (clone/install can take a while).
+- Idempotent re-opens skip and are near-instant.
+
+## Security (the crux)
+
+- **Commands are host-authored** (`setup.sh` lives on the host). The link/viewer
+  supplies only `owner/repo/branch` identity — never commands.
+- codehost **sanitizes** `owner/repo/branch` before handing them to `setup.sh`
+  (reject `;`, `$()`, backticks, newlines, `..`, path separators where not
+  expected) and passes them as **env**, not string-interpolated into a command.
+- **allowlist** (`config.yaml` / `setup.sh`) gates which repos auto-provision;
+  others prompt or are denied.
+- Any room member can trigger `setup.sh` with any identity, so the **room token
+  is the trust boundary** and `setup.sh`/allowlist owns repo policy. Editing
+  config (= changing what runs on the host) may warrant owner auth beyond the
+  room token — open question.
+
+## Defaults / scaffolding
+
+- No `.codehost/setup.sh` → fall back to today's behavior (resolve to the layout
+  path, no clone).
+- `codehost init` scaffolds a starter `.codehost/` (`config.yaml` + a `setup.sh`
+  that does `gh repo clone` + `git worktree add` + the `ws/` convention).
+
+## Related fix (independent, same path)
+
+`resolveRepoTarget` picks the *first* root daemon without checking which one
+actually contains the repo, so with multiple roots it can pick the wrong one
+(observed live: it chose `/Users/sno` over the correct `/Users/sno/ws`, yielding
+a non-existent subpath). Prefer the **deepest matching root** (longest `cwd`
+prefix). Not part of provisioning, but it gates the same "open a repo" path.
+
+## Open questions
+
+1. Source of truth for the path: `setup.sh` stdout vs `config.yaml` template.
+   (Proposed: stdout wins; the template is the default handed in as `CODEHOST_WS`.)
+2. Owner auth for editing config beyond the room token?
+3. Log streaming transport: a new tunnel channel vs reuse of an existing one.

package/package.json

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

package/src/shared/repo.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { parseDeepLink, pickRoomMatch, repoKey, resolveDevTarget, shareableDeepLink, toPosixPath } from "./repo";
+import { gitUrlToPath, parseDeepLink, pickRoomMatch, repoKey, resolveDevTarget, resolveRepoTarget, shareableDeepLink, toPosixPath } from "./repo";
 import type { PeerInfo } from "./signaling";
 import { parseGitRemote } from "../cli/git";
 
@@ -194,6 +194,53 @@ describe("shareableDeepLink", () => {
   });
 });
 
+describe("resolveRepoTarget root selection", () => {
+  const root = (peerId: string, cwd: string): PeerInfo => ({
+    peerId,
+    role: "server",
+    meta: { name: peerId, host: "Mac", cwd, kind: "root" },
+  });
+
+  test("among nested roots, picks the deepest (longest cwd)", () => {
+    const servers = [root("shallow", "/Users/sno"), root("deep", "/Users/sno/ws")];
+    const res = resolveRepoTarget(servers, { host: "github.com", owner: "snomiao", name: "codehost" });
+    expect(res?.peerId).toBe("deep");
+    expect(res?.folder).toBe("/Users/sno/ws/snomiao/codehost/tree/main");
+  });
+
+  test("an exact repo daemon still wins over any root", () => {
+    const servers: PeerInfo[] = [
+      root("deep", "/Users/sno/ws"),
+      { peerId: "exact", role: "server", meta: { name: "x", host: "Mac", cwd: "/x", repo: "github.com/snomiao/codehost" } },
+    ];
+    expect(resolveRepoTarget(servers, { host: "github.com", owner: "snomiao", name: "codehost" })?.peerId).toBe("exact");
+  });
+});
+
+describe("gitUrlToPath", () => {
+  test("github URLs -> /gh, preserving branch (incl. slashes)", () => {
+    expect(gitUrlToPath("https://github.com/snomiao/codehost")).toBe("/gh/snomiao/codehost");
+    expect(gitUrlToPath("https://github.com/snomiao/codehost/tree/main")).toBe("/gh/snomiao/codehost/tree/main");
+    expect(gitUrlToPath("github.com/snomiao/codehost")).toBe("/gh/snomiao/codehost");
+    expect(gitUrlToPath("https://github.com/snomiao/codehost.git")).toBe("/gh/snomiao/codehost");
+    expect(gitUrlToPath("https://github.com/snomiao/codehost/tree/feat/x")).toBe("/gh/snomiao/codehost/tree/feat/x");
+    expect(gitUrlToPath("https://github.com/snomiao/codehost/")).toBe("/gh/snomiao/codehost");
+    expect(gitUrlToPath("https://github.com/snomiao/codehost?tab=readme#x")).toBe("/gh/snomiao/codehost");
+  });
+
+  test("other hosts + scp form -> /git/<host>/...", () => {
+    expect(gitUrlToPath("https://gitlab.com/group/proj/tree/dev")).toBe("/git/gitlab.com/group/proj/tree/dev");
+    expect(gitUrlToPath("git@github.com:snomiao/codehost.git")).toBe("/gh/snomiao/codehost");
+  });
+
+  test("non-repo / junk -> null", () => {
+    expect(gitUrlToPath("")).toBeNull();
+    expect(gitUrlToPath("not a url")).toBeNull();
+    expect(gitUrlToPath("https://github.com/snomiao")).toBeNull(); // no repo
+    expect(gitUrlToPath("/gh/snomiao/codehost")).toBeNull(); // already a deep link, no host
+  });
+});
+
 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" } };

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". */
@@ -96,12 +100,12 @@ 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);
 }
 
 /**
@@ -133,6 +137,28 @@ export function shareableDeepLink(opts: {
   return null;
 }
 
+/**
+ * Turn a pasted git repo URL into a codehost deep-link path: github.com ->
+ * `/gh/<owner>/<repo>`, any other host -> `/git/<host>/<owner>/<repo>`,
+ * preserving `/tree/<branch>`. Accepts with or without a scheme, an `scp`-style
+ * `git@host:owner/repo`, a trailing `.git`, query/hash, and a branch containing
+ * slashes. Returns null when it isn't a recognizable repo URL — lets the "open a
+ * GitHub URL" box reuse the same resolution as a typed deep link.
+ */
+export function gitUrlToPath(input: string): string | null {
+  let s = input.trim();
+  if (!s) return null;
+  s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//i, ""); // scheme://
+  s = s.replace(/^[^@/]+@/, ""); // user@ (incl. git@)
+  s = s.replace(/^([^/:]+):(?!\d)/, "$1/"); // scp-style host:owner/repo -> host/owner/repo
+  s = s.split(/[?#]/)[0].replace(/\/+$/, ""); // drop query/hash + trailing slash
+  const m = s.match(/^([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/(.+))?$/);
+  if (!m) return null;
+  const host = m[1].toLowerCase();
+  if (!host.includes(".")) return null; // require a real hostname (github.com)
+  return shareableDeepLink({ repo: `${host}/${m[2]}/${m[3]}`, branch: m[4] });
+}
+
 export interface Resolution {
   peerId: string;
   /** Folder to open via ?folder= (root kind); undefined opens the repo as-is. */
@@ -142,7 +168,10 @@ export interface Resolution {
 /**
  * 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.
- * Returns null if nothing matches.
+ * 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.
  */
 export function resolveRepoTarget(servers: PeerInfo[], target: RepoTarget): Resolution | null {
   const key = repoKey(target);
@@ -151,7 +180,9 @@ export function resolveRepoTarget(servers: PeerInfo[], target: RepoTarget): Reso
   );
   if (repoMatch) return { peerId: repoMatch.peerId };
 
-  const root = servers.find((s) => s.meta?.kind === "root");
+  const root = servers
+    .filter((s) => s.meta?.kind === "root")
+    .sort((a, b) => (b.meta?.cwd.length ?? 0) - (a.meta?.cwd.length ?? 0))[0];
   if (root && root.meta) {
     const folder = `${trimSlash(root.meta.cwd)}/${fillLayout(root.meta.layout || DEFAULT_LAYOUT, target)}`;
     return { peerId: root.peerId, folder };

package/src/web/discovery.tsx

@@ -8,8 +8,10 @@ import { getSignalUrl } from "./config";
 import { registerTunnelHost } from "./tunnel-host";
 import { connBroker } from "./conn-broker";
 import {
+  DEFAULT_BRANCH,
   type DeepLink,
   type RoomMatch,
+  gitUrlToPath,
   parseDeepLink,
   pickRoomMatch,
   repoKey,
@@ -161,6 +163,12 @@ export function Discovery() {
   const [editingToken, setEditingToken] = useState(false);
   const [tokenError, setTokenError] = useState<string | null>(null);
 
+  // "Open a GitHub repo" box: paste a github.com URL -> navigate to its /gh/
+  // deep link, which resolves/opens (and, once provisioning lands, materializes)
+  // the workspace.
+  const [ghUrl, setGhUrl] = useState("");
+  const [ghError, setGhError] = useState<string | null>(null);
+
   // Fake-tag filter over the merged workspace list: a free-text box plus a set
   // of pinned tag tokens (chips). Both feed the same `ay ls`-style AND matcher.
   const [filter, setFilter] = useState("");
@@ -311,6 +319,22 @@ export function Discovery() {
     setEditingToken(false);
   }
 
+  function openGithubUrl(e: React.FormEvent) {
+    e.preventDefault();
+    const path = gitUrlToPath(ghUrl);
+    if (!path) {
+      setGhError("not a recognizable git repo URL");
+      return;
+    }
+    setGhError(null);
+    setGhUrl("");
+    // Navigate to the deep link and reconcile: connect if a daemon already
+    // serves it (provisioning, later, will materialize it when it doesn't).
+    history.pushState(null, "", path);
+    setResolving(deepLinkLabel(parseDeepLink(path)));
+    syncToUrl();
+  }
+
   function leaveRoom(t: string) {
     if (activeRoomRef.current === t) disconnect();
     setTokens((prev) => prev.filter((x) => x !== t));
@@ -356,10 +380,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
@@ -417,14 +450,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,
-          host: server.meta?.host,
-        });
+    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() {
@@ -719,6 +758,26 @@ export function Discovery() {
             </>
           )}
 
+          {tokens.length > 0 && (
+            <>
+              <form onSubmit={openGithubUrl} style={styles.ghForm}>
+                <input
+                  value={ghUrl}
+                  onChange={(e) => {
+                    setGhUrl(e.target.value);
+                    if (ghError) setGhError(null);
+                  }}
+                  placeholder="open a repo…  paste a github.com URL"
+                  style={styles.input}
+                />
+                <button type="submit" style={styles.button}>
+                  Open
+                </button>
+              </form>
+              {ghError && <p style={styles.tokenError}>{ghError}</p>}
+            </>
+          )}
+
           <div style={styles.listHead}>
             <h2 style={styles.h2}>Workspaces</h2>
             {serverCount > 0 && (
@@ -820,6 +879,7 @@ const styles: Record<string, React.CSSProperties> = {
   roomChipX: { background: "transparent", border: "none", color: "inherit", cursor: "pointer", fontSize: 11, padding: 0, lineHeight: 1 },
   input: { flex: 1, background: "#252525", border: "1px solid #3d3d3d", color: "#eee", padding: "8px 10px", borderRadius: 6, fontSize: 13, outline: "none" },
   button: { background: "#0e639c", border: "none", color: "#fff", padding: "8px 16px", borderRadius: 6, cursor: "pointer", fontSize: 13 },
+  ghForm: { display: "flex", alignItems: "center", gap: 8, margin: "0 0 14px" },
   listHead: { display: "flex", alignItems: "baseline", gap: 10, margin: "0 0 12px" },
   h2: { fontSize: 14, color: "#aaa", fontWeight: 600, margin: 0 },
   count: { fontSize: 12, color: "#888", fontFamily: "monospace" },