codehost 0.1.1 → 0.4.0

package/src/cli/oxmgr-heal.ts

@@ -0,0 +1,175 @@
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  copyFileSync,
+  createWriteStream,
+  existsSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import https from "node:https";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+// Self-heal oxmgr's native binary. Two real-world gaps:
+//   1. Under bunx/bun (and `bun i -g`), install lifecycle scripts are skipped,
+//      so oxmgr's postinstall never downloads its prebuilt — the vendored
+//      binary is simply absent.
+//   2. On older Linux distros, the downloaded `*-linux-gnu` prebuilt needs a
+//      newer glibc than the host has (GLIBC_x.y not found).
+// Linux is healed by swapping in oxmgr's fully static `*-linux-musl` build (no
+// libc dependency, also covers the missing case). Other platforms are healed by
+// running oxmgr's own installer via the current runtime (bun) to fetch the
+// right binary — no Node required. Mirrors the node-datachannel self-heal.
+
+const require = createRequire(import.meta.url);
+let healAttempted = false;
+
+interface OxmgrInstall {
+  /** oxmgr package root. */
+  root: string;
+  /** Platform-correct vendored binary path. */
+  vendorBin: string;
+  version: string;
+  /** GitHub "owner/repo" the release assets live under. */
+  slug: string;
+}
+
+/** Repair oxmgr's binary. Idempotent within a process. */
+export async function healOxmgr(): Promise<boolean> {
+  if (healAttempted) return false;
+  healAttempted = true;
+
+  const install = locateOxmgr();
+  if (!install) return false;
+
+  // Linux: portable musl static build covers both the glibc mismatch and a
+  // missing binary in one download.
+  if (process.platform === "linux") return swapMusl(install);
+
+  // Windows / macOS: run oxmgr's own installer to fetch the platform binary the
+  // skipped postinstall never downloaded.
+  return runInstaller(install);
+}
+
+/** Run oxmgr's bundled installer via the current runtime (bun) to fetch its
+ *  native binary. Cross-platform; no Node needed. */
+function runInstaller(install: OxmgrInstall): boolean {
+  const script = join(install.root, "scripts", "install.js");
+  if (!existsSync(script)) return false;
+  console.log("[codehost] fetching oxmgr's native binary…");
+  const r = spawnSync(process.execPath, [script], { cwd: install.root, stdio: "inherit" });
+  return r.status === 0 && existsSync(install.vendorBin);
+}
+
+/** Download + install oxmgr's static musl binary (Linux). */
+async function swapMusl(install: OxmgrInstall): Promise<boolean> {
+  const target = process.arch === "x64" ? "x86_64-unknown-linux-musl" : process.arch === "arm64" ? "aarch64-unknown-linux-musl" : null;
+  if (!target) return false;
+
+  const archive = `oxmgr-v${install.version}-${target}.tar.gz`;
+  const base =
+    process.env.OXMGR_DIST_BASE ||
+    `https://github.com/${install.slug}/releases/download/v${install.version}`;
+  const url = `${base}/${archive}`;
+
+  const tmp = mkdtempSync(join(tmpdir(), "oxmgr-heal-"));
+  const archivePath = join(tmp, archive);
+  console.log("[codehost] fetching oxmgr's portable (musl) binary…");
+  try {
+    await download(url, archivePath);
+    const untar = spawnSync("tar", ["xzf", archivePath, "-C", tmp], { stdio: "ignore" });
+    if (untar.status !== 0) throw new Error("could not extract the archive (is `tar` installed?)");
+    const binary = findFile(tmp, "oxmgr");
+    if (!binary) throw new Error("musl archive did not contain an oxmgr binary");
+    // Unlink first so we can replace a binary that's currently executing (ETXTBSY).
+    rmSync(install.vendorBin, { force: true });
+    copyFileSync(binary, install.vendorBin);
+    chmodSync(install.vendorBin, 0o755);
+    console.log("[codehost] oxmgr repaired with its static musl build.");
+    return true;
+  } catch (err) {
+    console.error(`[codehost] automatic oxmgr repair failed: ${(err as Error).message}`);
+    return false;
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+/** Resolve oxmgr's on-disk install from codehost's own node_modules. */
+function locateOxmgr(): OxmgrInstall | null {
+  let pkgPath: string;
+  try {
+    pkgPath = require.resolve("oxmgr/package.json");
+  } catch {
+    return null;
+  }
+  const root = dirname(pkgPath);
+  const vendorBin = join(root, "vendor", process.platform === "win32" ? "oxmgr.exe" : "oxmgr");
+
+  let pkg: { version?: string; repository?: { url?: string } };
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!pkg.version) return null;
+  return { root, vendorBin, version: pkg.version, slug: oxmgrSlug(pkg) };
+}
+
+/** GitHub slug for oxmgr's releases, matching its own installer's resolution. */
+function oxmgrSlug(pkg: { repository?: { url?: string } }): string {
+  if (process.env.OXMGR_NPM_REPOSITORY) return process.env.OXMGR_NPM_REPOSITORY;
+  const url = pkg.repository?.url ?? "";
+  const m = url.match(/github\.com[/:]([^/]+\/[^/.]+)(?:\.git)?$/i);
+  return m ? m[1] : "Vladimir-Urik/OxMgr";
+}
+
+/** Download a URL to a file, following GitHub's redirect to release-assets. */
+function download(url: string, dest: string): Promise<void> {
+  return new Promise((resolvePromise, reject) => {
+    const file = createWriteStream(dest);
+    https
+      .get(url, (res) => {
+        const status = res.statusCode ?? 0;
+        if ([301, 302, 307, 308].includes(status)) {
+          const location = res.headers.location;
+          file.close();
+          rmSync(dest, { force: true });
+          if (!location) return reject(new Error(`redirect without location for ${url}`));
+          return download(location, dest).then(resolvePromise).catch(reject);
+        }
+        if (status !== 200) {
+          file.close();
+          rmSync(dest, { force: true });
+          return reject(new Error(`download failed (HTTP ${status})`));
+        }
+        res.pipe(file);
+        file.on("finish", () => file.close(() => resolvePromise()));
+      })
+      .on("error", (err) => {
+        file.close();
+        rmSync(dest, { force: true });
+        reject(err);
+      });
+  });
+}
+
+/** Depth-first search for a file named `name` under `dir`. */
+function findFile(dir: string, name: string): string | null {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      const found = findFile(full, name);
+      if (found) return found;
+    } else if (entry === name) {
+      return full;
+    }
+  }
+  return null;
+}

package/src/cli/oxmgr.ts

@@ -1,16 +1,76 @@
-import { spawnSync } from "node:child_process";
+import { type SpawnSyncOptions, spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { healOxmgr } from "./oxmgr-heal";
 
-// Thin wrapper around the `oxmgr` process manager (https://npmjs.com/package/oxmgr).
-// `codehost serve -d` re-launches the foreground `serve` under oxmgr so it
-// survives the shell and restarts on failure.
+// Wrapper around the `oxmgr` process manager (https://npmjs.com/package/oxmgr),
+// used by `serve|dev|expose -d` to run the foreground command as a managed,
+// restart-on-failure daemon.
+//
+// oxmgr is a *dependency* of codehost, and we invoke it via the current runtime
+// (bun) using its resolved JS entry — never the bare `oxmgr` command. That
+// avoids the Windows failure where `spawnSync("oxmgr")` can't resolve a PATH
+// shim without the .exe/.cmd extension, and needs no Node and no global install.
 
+const require = createRequire(import.meta.url);
+
+/** Resolve oxmgr's JS CLI entry from codehost's own node_modules. */
+function oxmgrEntry(): string | null {
+  try {
+    return require.resolve("oxmgr/bin/oxmgr.js");
+  } catch {
+    return null;
+  }
+}
+
+/** Run the oxmgr CLI via bun. Returns the exit status (1 if unresolvable). */
+function ox(args: string[], opts: SpawnSyncOptions = {}): number {
+  const entry = oxmgrEntry();
+  if (!entry) return 1;
+  const r = spawnSync(process.execPath, [entry, ...args], opts);
+  return r.status ?? 1;
+}
+
+type OxmgrState = "ok" | "broken" | "missing";
+
+/** Probe oxmgr: "missing" = not installed; "broken" = installed but its binary
+ *  won't run (no vendored prebuilt yet, or a glibc/platform mismatch). */
+function probeOxmgr(): OxmgrState {
+  const entry = oxmgrEntry();
+  if (!entry) return "missing";
+  const r = spawnSync(process.execPath, [entry, "--version"], { encoding: "utf8" });
+  return r.status === 0 ? "ok" : "broken";
+}
+
+/** Quick non-repairing probe (used where we only need a yes/no). */
 export function hasOxmgr(): boolean {
-  const r = spawnSync("oxmgr", ["--version"], { stdio: "ignore" });
-  return r.status === 0;
+  return probeOxmgr() === "ok";
+}
+
+/**
+ * Ensure a runnable oxmgr, self-healing a broken/missing prebuilt (see
+ * oxmgr-heal.ts) — the common case under bunx/bun where install lifecycle
+ * scripts are skipped so oxmgr's binary was never downloaded. Returns true if
+ * oxmgr is usable afterwards.
+ */
+export async function ensureOxmgr(): Promise<boolean> {
+  const state = probeOxmgr();
+  if (state === "ok") return true;
+  if (state === "missing") {
+    console.error(MISSING_MSG);
+    return false;
+  }
+  if (await healOxmgr()) return probeOxmgr() === "ok";
+  console.error(BROKEN_MSG);
+  return false;
 }
 
 const MISSING_MSG =
-  "[codehost] oxmgr not found. Install it with `npm i -g oxmgr` (or `bun add -g oxmgr`), then retry with -d.";
+  "[codehost] oxmgr is not available. Reinstall codehost so its dependency is present " +
+  "(`bun add -g codehost` or `npm i -g codehost`), then retry with -d.";
+
+const BROKEN_MSG =
+  "[codehost] oxmgr is installed but its native binary couldn't be fetched/repaired " +
+  "automatically (check network access). Foreground `codehost serve` (without -d) still works.";
 
 /** Process name oxmgr will track this server under. */
 export function daemonName(label: string): string {
@@ -24,41 +84,49 @@ export interface DaemonizeOptions {
   cwd: string;
 }
 
-/** Start the foreground serve under oxmgr. Returns false if oxmgr is missing. */
-export function startDaemon(opts: DaemonizeOptions): boolean {
-  if (!hasOxmgr()) {
-    console.error(MISSING_MSG);
-    return false;
-  }
+/** Start the foreground serve under oxmgr. Returns false if oxmgr is unusable. */
+export async function startDaemon(opts: DaemonizeOptions): Promise<boolean> {
+  if (!(await ensureOxmgr())) return false;
   // Replace any previous instance with the same name.
-  spawnSync("oxmgr", ["delete", opts.name], { stdio: "ignore" });
-
-  const r = spawnSync(
-    "oxmgr",
-    ["start", opts.command, "--name", opts.name, "--cwd", opts.cwd, "--restart", "on-failure"],
-    { stdio: "inherit" },
-  );
-  return r.status === 0;
+  ox(["delete", opts.name], { stdio: "ignore" });
+
+  const ok =
+    ox(
+      ["start", opts.command, "--name", opts.name, "--cwd", opts.cwd, "--restart", "on-failure"],
+      { stdio: "inherit" },
+    ) === 0;
+  if (ok) enableStartup();
+  return ok;
 }
 
-/** `codehost list` -> oxmgr's process table. */
-export function listDaemons(): number {
-  if (!hasOxmgr()) {
-    console.error(MISSING_MSG);
-    return 1;
+/**
+ * Best-effort: install oxmgr's platform service (systemd `--user` / launchd /
+ * Task Scheduler) so the daemon — and the codehost process it manages, whose
+ * metadata oxmgr persists — comes back when the user logs in again. Idempotent
+ * and non-fatal: hosts without an init system just get a hint.
+ */
+function enableStartup(): void {
+  const ok = ox(["service", "--system", "auto", "install"], { stdio: "pipe" }) === 0;
+  if (ok) {
+    console.log("[codehost] login auto-start enabled (oxmgr service installed)");
+  } else {
+    console.log(
+      "[codehost] note: couldn't auto-enable login startup here; run oxmgr's `startup` " +
+        "integration on a systemd/launchd host to make it persist across logins.",
+    );
   }
-  const r = spawnSync("oxmgr", ["list"], { stdio: "inherit" });
-  return r.status ?? 0;
+}
+
+/** `codehost list` -> oxmgr's process table. */
+export async function listDaemons(): Promise<number> {
+  if (!(await ensureOxmgr())) return 1;
+  return ox(["list"], { stdio: "inherit" });
 }
 
 /** `codehost stop <name>` -> stop + delete the oxmgr process. */
-export function stopDaemon(name: string): number {
-  if (!hasOxmgr()) {
-    console.error(MISSING_MSG);
-    return 1;
-  }
+export async function stopDaemon(name: string): Promise<number> {
+  if (!(await ensureOxmgr())) return 1;
   const full = name.startsWith("codehost-") ? name : daemonName(name);
-  spawnSync("oxmgr", ["stop", full], { stdio: "inherit" });
-  const r = spawnSync("oxmgr", ["delete", full], { stdio: "inherit" });
-  return r.status ?? 0;
+  ox(["stop", full], { stdio: "inherit" });
+  return ox(["delete", full], { stdio: "inherit" });
 }

package/src/cli/run-server.ts

@@ -0,0 +1,78 @@
+import { type PeerMeta, newPeerId } from "../shared/signaling";
+import { SignalingClient } from "../shared/signaling-client";
+import { RtcDaemon } from "./rtc-daemon";
+import { Tunnel } from "./tunnel";
+
+export interface LaunchResult {
+  /** Local port to tunnel to. */
+  port: number;
+  /** Stop the launched process, if any. */
+  stop?: () => void;
+  /**
+   * Prefix the Tunnel should strip before forwarding (so an arbitrary server
+   * that doesn't know about /vs/<peerId> still gets clean paths). Left undefined
+   * for VS Code, which is launched with --server-base-path and wants the prefix.
+   */
+  stripBasePath?: string;
+}
+
+export interface RunServerOptions {
+  token: string;
+  signal: string;
+  meta: PeerMeta;
+  /** One-line description for the startup log. */
+  label: string;
+  /** Prepare the local target to tunnel, given the /vs/<peerId> base path. */
+  launch: (basePath: string) => Promise<LaunchResult>;
+}
+
+/**
+ * Foreground server loop shared by `serve`, `dev`, and `expose`: register in the
+ * signaling room with the given meta and bridge each viewer's data channel to a
+ * local server (VS Code for serve/dev, an arbitrary port for expose). Never
+ * resolves.
+ */
+export async function runServer(opts: RunServerOptions): Promise<never> {
+  const peerId = newPeerId();
+  const basePath = `/vs/${peerId}`;
+
+  console.log(`[codehost] ${opts.label}`);
+  console.log(`[codehost] room token: ${opts.token}`);
+  console.log(`[codehost] signaling:  ${opts.signal}`);
+
+  const target = await opts.launch(basePath);
+
+  let rtc: RtcDaemon;
+  const client = new SignalingClient({
+    url: opts.signal,
+    token: opts.token,
+    role: "server",
+    peerId,
+    meta: opts.meta,
+    onOpen: () => console.log(`[codehost] registered as "${opts.meta.name}" (${peerId.slice(0, 8)})`),
+    onClose: () => console.log("[codehost] disconnected from signaling, reconnecting…"),
+    onSignal: (from, data) => rtc.handleSignal(from, data),
+  });
+
+  rtc = new RtcDaemon({
+    sendSignal: (to, data) => client.sendSignal(to, data),
+    onChannel: (viewerId, channel) => {
+      console.log(`[codehost] viewer ${viewerId.slice(0, 8)} connected; bridging to :${target.port}`);
+      new Tunnel(channel, target.port, target.stripBasePath);
+    },
+  });
+
+  client.connect();
+
+  const shutdown = () => {
+    console.log("\n[codehost] shutting down");
+    rtc.closeAll();
+    client.close();
+    target.stop?.();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  return new Promise<never>(() => {});
+}

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/cli/tunnel.ts

@@ -47,6 +47,13 @@ export class Tunnel {
   constructor(
     private channel: DataChannel,
     private vscodePort: number,
+    /**
+     * Prefix to strip from incoming paths before forwarding to the local server.
+     * VS Code is launched with --server-base-path /vs/<peerId> so it WANTS the
+     * prefix (left undefined). An arbitrary exposed server (`codehost expose`)
+     * doesn't know it, so we strip `/vs/<peerId>` before proxying.
+     */
+    private stripPrefix?: string,
   ) {
     this.origin = `http://127.0.0.1:${vscodePort}`;
     this.wsOrigin = `ws://127.0.0.1:${vscodePort}`;
@@ -58,6 +65,15 @@ export class Tunnel {
     this.channel.onClosed(() => this.closeAll());
   }
 
+  /** Map a tunneled path to the local server's path, stripping the base prefix. */
+  private localPath(path: string): string {
+    if (this.stripPrefix && path.startsWith(this.stripPrefix)) {
+      const rest = path.slice(this.stripPrefix.length);
+      return rest.startsWith("/") ? rest : `/${rest}`;
+    }
+    return path;
+  }
+
   private async onFrame(data: Uint8Array): Promise<void> {
     const { op, streamId, payload } = decodeFrame(data);
     switch (op) {
@@ -99,16 +115,26 @@ export class Tunnel {
 
     const { method, path, headers } = stream.head;
     const reqHeaders = new Headers();
+    let forwardedHost = "";
     for (const [k, v] of Object.entries(headers)) {
-      if (!HOP_BY_HOP.has(k.toLowerCase())) reqHeaders.set(k, v);
+      const lk = k.toLowerCase();
+      if (lk === "x-forwarded-host") {
+        forwardedHost = v;
+        continue;
+      }
+      if (!HOP_BY_HOP.has(lk)) reqHeaders.set(k, v);
     }
-    reqHeaders.set("host", `127.0.0.1:${this.vscodePort}`);
+    // Present the browser's public host to VS Code so its client-side
+    // remoteAuthority points at codehost.dev (routes resource URLs back through
+    // the tunnel), not the unreachable 127.0.0.1:<port>. Falls back to the local
+    // host if the SW didn't forward one.
+    reqHeaders.set("host", forwardedHost || `127.0.0.1:${this.vscodePort}`);
 
     const hasBody = method !== "GET" && method !== "HEAD" && stream.body.length > 0;
     const body = hasBody ? concat(stream.body) : undefined;
 
     try {
-      const res = await fetch(this.origin + path, {
+      const res = await fetch(this.origin + this.localPath(path), {
         method,
         headers: reqHeaders,
         body: body as BodyInit | undefined,
@@ -151,7 +177,7 @@ export class Tunnel {
   private openWs(streamId: number, info: { path: string; protocols?: string[] }): void {
     let ws: WebSocket;
     try {
-      ws = new WebSocket(this.wsOrigin + info.path, info.protocols);
+      ws = new WebSocket(this.wsOrigin + this.localPath(info.path), info.protocols);
     } catch (err) {
       void this.send(encodeJson(Op.WsOpenAck, streamId, { ok: false, error: String(err) }));
       return;

package/src/cli/vscode.ts

@@ -24,6 +24,10 @@ export interface LaunchOptions {
  */
 export async function launchVscode(opts: LaunchOptions): Promise<VscodeServer> {
   const port = opts.port && opts.port > 0 ? opts.port : await freePort();
+  // NB: no `--default-folder` — current VS Code `serve-web` (≥1.x) doesn't
+  // accept it and exits with "unexpected argument". The workspace is opened by
+  // the browser instead, via the `?folder=` query the page appends to the
+  // iframe URL (see src/web/discovery.tsx). `cwd` below still roots the server.
   const args = [
     "serve-web",
     "--host",
@@ -32,8 +36,6 @@ export async function launchVscode(opts: LaunchOptions): Promise<VscodeServer> {
     String(port),
     "--server-base-path",
     opts.basePath,
-    "--default-folder",
-    opts.dir,
     "--without-connection-token",
     "--accept-server-license-terms",
   ];

package/src/shared/repo.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { toPosixPath } from "./repo";
+
+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");
+  });
+});