codehost 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.6.0](https://github.com/snomiao/codehost/compare/v0.5.1...v0.6.0) (2026-06-08)
+
+
+### Features
+
+* detached fallback daemon when oxmgr is unavailable ([3aeddad](https://github.com/snomiao/codehost/commit/3aeddad595a2fc65f8a65050a5cc6171f41bca8f))
+
+## [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.6.0",
   "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/list.ts

@@ -1,11 +1,26 @@
 import type { CommandModule } from "yargs";
-import { listDaemons } from "../oxmgr";
+import { hasOxmgr, listDaemons } from "../oxmgr";
+import { listFallbackDaemons } from "../fallback-daemon";
 
 export const listCommand: CommandModule = {
   command: "list",
   aliases: ["ls"],
-  describe: "List codehost servers running under oxmgr",
+  describe: "List codehost servers (oxmgr-managed and detached)",
   handler: async () => {
-    process.exit(await listDaemons());
+    const detached = listFallbackDaemons();
+    if (detached.length) {
+      console.log("Detached daemons (no oxmgr):");
+      for (const d of detached) {
+        console.log(`  ${d.name}  pid ${d.pid}  ${d.cwd}  (log: ${d.log})`);
+      }
+      console.log("");
+    }
+    // Only hit oxmgr if it's actually runnable — `hasOxmgr` doesn't self-heal,
+    // so a broken install won't re-download its binary on every `list`.
+    if (await hasOxmgr()) {
+      process.exit(await listDaemons());
+    }
+    if (!detached.length) console.log("No codehost daemons running.");
+    process.exit(0);
   },
 };

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/commands/stop.ts

@@ -1,5 +1,6 @@
 import type { CommandModule } from "yargs";
-import { stopDaemon } from "../oxmgr";
+import { daemonName, stopDaemon } from "../oxmgr";
+import { stopFallbackDaemon } from "../fallback-daemon";
 
 interface StopArgs {
   name: string;
@@ -15,6 +16,13 @@ export const stopCommand: CommandModule<{}, StopArgs> = {
       demandOption: true,
     }) as any,
   handler: async (argv) => {
+    // Detached daemons are tracked locally; check those first so we don't poke
+    // (and possibly re-download) oxmgr when it isn't even managing this one.
+    const full = argv.name.startsWith("codehost-") ? argv.name : daemonName(argv.name);
+    if (stopFallbackDaemon(full) || stopFallbackDaemon(argv.name)) {
+      console.log(`[codehost] stopped ${full}`);
+      process.exit(0);
+    }
     process.exit(await stopDaemon(argv.name));
   },
 };

package/src/cli/commands/supervise.ts

@@ -0,0 +1,24 @@
+import type { CommandModule } from "yargs";
+import { runSupervisor } from "../fallback-daemon";
+
+interface SuperviseArgs {
+  name: string;
+  argv: string;
+}
+
+// Hidden internal command: the supervisor process behind a detached fallback
+// daemon (see fallback-daemon.ts). Not meant to be run by hand — `serve -d` /
+// `setup` spawn it when oxmgr isn't available.
+export const superviseCommand: CommandModule<{}, SuperviseArgs> = {
+  command: "__supervise",
+  describe: false, // hidden from help
+  builder: (y) =>
+    y
+      .option("name", { type: "string", demandOption: true })
+      .option("argv", { type: "string", demandOption: true, describe: "JSON-encoded serve argv" }) as any,
+  handler: async (a) => {
+    const argv = JSON.parse(a.argv) as string[];
+    const code = await runSupervisor(a.name, argv);
+    process.exit(code);
+  },
+};

package/src/cli/daemonize.ts

@@ -1,5 +1,6 @@
 import { daemonName, startDaemon } from "./oxmgr";
 import { selfUpdate } from "./self-update";
+import { startFallbackDaemon } from "./fallback-daemon";
 
 export interface ServeDaemonOptions {
   /** Subcommand to re-launch under oxmgr. */
@@ -28,8 +29,11 @@ export interface ServeDaemonResult {
 }
 
 /**
- * Launch a foreground `codehost serve` (without -d) under oxmgr so it survives
- * the shell and restarts on failure. Shared by `serve -d` and `setup`.
+ * Launch a foreground `codehost serve` (without -d) so it survives the shell and
+ * restarts on failure. Prefers oxmgr (which also adds login auto-start); when
+ * oxmgr can't run here (e.g. broken native binary on Windows) it falls back to a
+ * detached, self-restarting child instead of failing. `CODEHOST_NO_OXMGR=1`
+ * forces the fallback. 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
@@ -39,25 +43,39 @@ export async function launchServeDaemon(opts: ServeDaemonOptions): Promise<Serve
 
   const label = opts.name ?? opts.dir.split("/").pop() ?? opts.host;
   const name = daemonName(label);
-  const command = buildForegroundCommand(opts);
-  console.log(`[codehost] starting daemon "${name}" via oxmgr`);
-  const ok = await startDaemon({ name, command, cwd: opts.dir });
+  const argv = buildForegroundArgv(opts);
+
+  if (process.env.CODEHOST_NO_OXMGR !== "1") {
+    console.log(`[codehost] starting daemon "${name}" via oxmgr`);
+    // startDaemon attempts to self-heal oxmgr once; false means it's unusable here.
+    const ok = await startDaemon({ name, command: argv.map(quote).join(" "), cwd: opts.dir });
+    if (ok) {
+      console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
+      return { ok: true, name };
+    }
+    console.warn("[codehost] oxmgr unavailable — falling back to a detached daemon (no login auto-start).");
+  }
+
+  const ok = startFallbackDaemon({ name, argv, cwd: opts.dir });
   if (ok) {
-    console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
+    console.log(`[codehost] detached daemon "${name}" started. View: codehost list · Stop: codehost stop ${name}`);
+  } else {
+    console.error("[codehost] failed to start a detached daemon.");
   }
   return { ok, name };
 }
 
 /**
- * Reconstruct the exact foreground `serve` invocation (without -d) for oxmgr to
- * run. Uses the same runtime + entry script that launched us, so it works both
- * for `bunx codehost` and local `bun src/cli/index.ts`.
+ * Reconstruct the exact foreground `serve` invocation (without -d) as an argv
+ * array. Uses the same runtime + entry script that launched us, so it works both
+ * for `bunx codehost` and local `bun src/cli/index.ts`. oxmgr takes a shell
+ * string (we quote+join); the fallback spawns the argv directly.
  */
-function buildForegroundCommand(opts: ServeDaemonOptions): string {
+function buildForegroundArgv(opts: ServeDaemonOptions): string[] {
   const parts = [process.execPath, process.argv[1], opts.command ?? "serve", opts.arg ?? opts.dir, "-t", opts.token, "--signal", opts.signal];
   if (opts.name) parts.push("--name", opts.name);
   if (opts.port) parts.push("--port", String(opts.port));
-  return parts.map(quote).join(" ");
+  return parts;
 }
 
 function quote(s: string): string {

package/src/cli/fallback-daemon.ts

@@ -0,0 +1,139 @@
+import { spawn, type Subprocess } from "bun";
+import { mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// A minimal, non-oxmgr daemon manager: a detached, self-restarting child that
+// survives the shell. Used as a fallback when oxmgr's native binary can't run
+// here (e.g. broken on a Windows box) so `-d`/`setup` still leave a running
+// server instead of failing or re-download-looping. Tracked in a JSON registry
+// so `codehost list`/`stop` can see and manage these alongside oxmgr daemons.
+//
+// Tradeoff vs oxmgr: no login auto-start (that's oxmgr's per-OS service bit). It
+// does survive the launching shell and restarts the server on crash.
+
+const ROOT = join(homedir(), ".codehost");
+const REGISTRY = join(ROOT, "daemons.json");
+const LOG_DIR = join(ROOT, "logs");
+
+export interface FallbackDaemon {
+  name: string;
+  /** Supervisor process pid. */
+  pid: number;
+  cwd: string;
+  /** The foreground serve argv the supervisor (re)spawns. */
+  argv: string[];
+  log: string;
+  startedAt: number;
+}
+
+function readRegistry(): FallbackDaemon[] {
+  try {
+    return JSON.parse(readFileSync(REGISTRY, "utf8")) as FallbackDaemon[];
+  } catch {
+    return [];
+  }
+}
+
+function writeRegistry(list: FallbackDaemon[]): void {
+  mkdirSync(dirname(REGISTRY), { recursive: true });
+  writeFileSync(REGISTRY, JSON.stringify(list, null, 2));
+}
+
+/** True if a pid is currently alive (signal 0 probe). */
+export function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start (replacing any same-named instance) a detached, self-restarting daemon
+ * that runs `argv` from `cwd`, with output appended to a per-daemon log. Returns
+ * false if the supervisor couldn't be spawned.
+ */
+export function startFallbackDaemon(opts: { name: string; argv: string[]; cwd: string }): boolean {
+  stopFallbackDaemon(opts.name); // replace any previous instance with this name
+
+  mkdirSync(LOG_DIR, { recursive: true });
+  const log = join(LOG_DIR, `${opts.name}.log`);
+  const fd = openSync(log, "a");
+  const proc = spawn(
+    [process.execPath, process.argv[1], "__supervise", "--name", opts.name, "--argv", JSON.stringify(opts.argv)],
+    { cwd: opts.cwd, stdin: "ignore", stdout: fd, stderr: fd },
+  );
+  // Detach so the launching process (setup / serve -d) can exit while this keeps
+  // running as an orphan.
+  proc.unref();
+  if (!proc.pid) return false;
+
+  const list = readRegistry().filter((d) => d.name !== opts.name);
+  list.push({ name: opts.name, pid: proc.pid, cwd: opts.cwd, argv: opts.argv, log, startedAt: Date.now() });
+  writeRegistry(list);
+  return true;
+}
+
+/** Live detached daemons (dead registry entries are pruned as a side effect). */
+export function listFallbackDaemons(): FallbackDaemon[] {
+  const list = readRegistry();
+  const alive = list.filter((d) => isAlive(d.pid));
+  if (alive.length !== list.length) writeRegistry(alive);
+  return alive;
+}
+
+/** Stop and deregister a detached daemon by name. Returns false if not found. */
+export function stopFallbackDaemon(name: string): boolean {
+  const list = readRegistry();
+  const hit = list.find((d) => d.name === name);
+  if (!hit) return false;
+  try {
+    process.kill(hit.pid); // SIGTERM -> supervisor kills its child, then exits
+  } catch {
+    // already gone
+  }
+  writeRegistry(list.filter((d) => d.name !== name));
+  return true;
+}
+
+/**
+ * Supervisor body (run via the hidden `__supervise` command). Runs the serve
+ * argv, restarting it on a non-zero exit with capped exponential backoff; stops
+ * when the child exits cleanly or when this process receives SIGTERM/SIGINT
+ * (killing the child first). Output goes to the inherited log fd.
+ */
+export async function runSupervisor(name: string, argv: string[]): Promise<number> {
+  let child: Subprocess | null = null;
+  let stopping = false;
+  const onSignal = () => {
+    stopping = true;
+    try {
+      child?.kill();
+    } catch {
+      // ignore
+    }
+  };
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+
+  let attempt = 0;
+  while (!stopping) {
+    console.log(`[codehost:${name}] starting: ${argv.join(" ")}`);
+    child = spawn(argv, { cwd: process.cwd(), stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+    const code = await child.exited;
+    if (stopping) break;
+    if (code === 0) {
+      console.log(`[codehost:${name}] server exited cleanly; supervisor stopping.`);
+      break;
+    }
+    attempt++;
+    const waitMs = Math.min(30_000, 1000 * 2 ** Math.min(attempt, 5));
+    console.error(
+      `[codehost:${name}] server exited with code ${code}; restarting in ${Math.round(waitMs / 1000)}s (attempt ${attempt}).`,
+    );
+    await Bun.sleep(waitMs);
+  }
+  return 0;
+}

package/src/cli/index.ts

@@ -8,6 +8,7 @@ import { exposeCommand } from "./commands/expose";
 import { listCommand } from "./commands/list";
 import { stopCommand } from "./commands/stop";
 import { updateCommand } from "./commands/update";
+import { superviseCommand } from "./commands/supervise";
 
 yargs(hideBin(process.argv))
   .scriptName("codehost")
@@ -19,6 +20,7 @@ yargs(hideBin(process.argv))
   .command(listCommand)
   .command(stopCommand)
   .command(updateCommand)
+  .command(superviseCommand)
   .demandCommand(1, "Specify a command, e.g. `codehost serve`")
   .strict()
   .help()

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, "/");