codehost 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [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)
 
 

package/package.json

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

package/src/cli/commands/dev.ts

@@ -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

@@ -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/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

@@ -3,23 +3,25 @@ import { parseDeepLink, pickRoomMatch, repoKey, shareableDeepLink, toPosixPath }
 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)", () => {
@@ -28,12 +30,20 @@ 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");
   });
 });
 
@@ -87,8 +97,16 @@ describe("parseDeepLink + repoKey round-trip", () => {
   });
 
   test("/dev/<path> -> dev target with leading slash", () => {
-    const dl = parseDeepLink("/dev/c/ws");
-    expect(dl?.type === "dev" && dl.target.path).toBe("/c/ws");
+    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", () => {
@@ -111,8 +129,9 @@ describe("shareableDeepLink", () => {
     );
   });
 
-  test("no repo -> /dev/<folder>", () => {
-    expect(shareableDeepLink({ folder: "/c/ws" })).toBe("/dev/c/ws");
+  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", () => {

package/src/shared/repo.ts

@@ -63,19 +63,22 @@ export function repoKey(t: Pick<RepoTarget, "host" | "owner" | "name">): string
 }
 
 /**
- * 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, "/");