codehost 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [0.4.0](https://github.com/snomiao/codehost/compare/v0.3.1...v0.4.0) (2026-06-08)
+
+
+### Bug Fixes
+
+* normalize Windows serve path to POSIX-drive form for VS Code web ([8add2d6](https://github.com/snomiao/codehost/commit/8add2d66a6b5ae765f91386f738ad38abcb90057))
+
+
+### Features
+
+* setup.sh/ps1 installer aliases + self-update to latest on serve/setup ([93a5d64](https://github.com/snomiao/codehost/commit/93a5d64170c5851ca0f488348975dae46f467b5e))
+
 ## [0.3.1](https://github.com/snomiao/codehost/compare/v0.3.0...v0.3.1) (2026-06-07)
 
 

package/README.md

@@ -32,6 +32,11 @@ curl -fsSL https://codehost.dev/install.sh | sh
 powershell -c "irm codehost.dev/install.ps1 | iex"
 ```
 
+`/setup.sh` and `/setup.ps1` are aliases of the same script. Re-running it any
+time **upgrades you to the latest codehost** (`bun add -g codehost@latest`), so
+it doubles as the updater — and it bootstraps Bun by absolute path, so it won't
+bail just because your shell hasn't picked Bun up on `PATH` yet.
+
 Already have Bun? `bun add -g codehost && codehost setup` does the same. Or, for
 a specific directory/token in one shot:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
     "deploy:signal": "cd worker && wrangler deploy",
     "deploy:pages": "vite build && wrangler pages deploy dist/public --project-name codehost",
     "start": "bun src/server.ts",
+    "test": "bun test",
     "typecheck": "tsc --noEmit && tsc --noEmit -p src/web/tsconfig.sw.json && tsc --noEmit -p worker/tsconfig.json"
   },
   "dependencies": {

package/public/_redirects

@@ -1,3 +1,8 @@
+# Friendly aliases for the installer: /setup.sh and /setup.ps1 serve the same
+# scripts as /install.*. Must precede the SPA catch-all below (first match wins).
+/setup.sh   /install.sh   200
+/setup.ps1  /install.ps1  200
+
 # SPA fallback: deep links like /gh/<owner>/<repo>/tree/<branch> and /dev/<path>
 # have no static file, so serve the app and let it route client-side. Cloudflare
 # Pages serves existing files first (/assets/*, /sw.js, /install.*), so only

package/public/install.ps1

@@ -1,12 +1,19 @@
-# codehost installer — https://codehost.dev
+# codehost installer / updater — https://codehost.dev
 #
 #   powershell -c "irm codehost.dev/install.ps1 | iex"
+#   powershell -c "irm codehost.dev/setup.ps1   | iex"   # same script, friendlier name
 #
-# Ensures Bun is installed, installs the `codehost` CLI globally (which fetches
-# the native WebRTC binary via Bun's lifecycle scripts), then runs `codehost
-# setup` to pick a token, install VS Code, and start a server daemon.
+# Ensures Bun is installed, installs/UPGRADES the `codehost` CLI globally to the
+# latest release (which fetches the native WebRTC binary via Bun's lifecycle
+# scripts), then runs `codehost setup` to pick a token, install VS Code, and
+# start a server daemon. Safe to re-run any time — it always lands you on the
+# newest codehost.
 #
-# Env override: $env:CODEHOST_NO_SETUP = "1"  -> install only, skip setup.
+# Bun is the runtime and can't be skipped — we bootstrap it and then invoke
+# everything by absolute path, so a not-yet-reloaded shell PATH never makes the
+# install "fail" after Bun is actually present.
+#
+# Env override: $env:CODEHOST_NO_SETUP = "1"  -> install/update only, skip setup.
 
 $ErrorActionPreference = "Stop"
 
@@ -15,29 +22,38 @@ function Fail($m) { Write-Host "[codehost] $m" -ForegroundColor Red; exit 1 }
 
 # Bun installs its global bin under %USERPROFILE%\.bun\bin by default.
 $bunBin = Join-Path $env:USERPROFILE ".bun\bin"
+$bunExe = Join-Path $bunBin "bun.exe"
 if (Test-Path $bunBin) { $env:Path = "$bunBin;$env:Path" }
 
-if (-not (Get-Command bun -ErrorAction SilentlyContinue)) {
+if (-not (Test-Path $bunExe)) {
   Info "Bun not found - installing from bun.sh..."
   Invoke-RestMethod https://bun.sh/install.ps1 | Invoke-Expression
   if (Test-Path $bunBin) { $env:Path = "$bunBin;$env:Path" }
 }
 
-if (-not (Get-Command bun -ErrorAction SilentlyContinue)) {
-  Fail "Bun install did not land on PATH. Open a new terminal and re-run."
+# Prefer the absolute path; fall back to a PATH lookup in case Bun honored a
+# custom install dir. Either way we never bail just because PATH wasn't reloaded.
+if (-not (Test-Path $bunExe)) {
+  $cmd = Get-Command bun -ErrorAction SilentlyContinue
+  if ($cmd) { $bunExe = $cmd.Source }
+  else { Fail "Bun was installed but bun.exe wasn't found at $bunBin. Open a new terminal and re-run." }
 }
 
-Info "installing the codehost CLI (bun add -g codehost)..."
-bun add -g codehost
+# `@latest` makes every re-run an upgrade, so users always end up on the newest
+# codehost instead of a stale globally-pinned copy.
+Info "installing the latest codehost CLI (bun add -g codehost@latest)..."
+& $bunExe add -g codehost@latest
 
-if (-not (Get-Command codehost -ErrorAction SilentlyContinue)) {
-  Fail "codehost installed but not on PATH. Add $bunBin to PATH and run: codehost setup"
-}
+# Resolve the codehost shim Bun just wrote (extension varies on Windows).
+$codehostCmd = Get-Command codehost -ErrorAction SilentlyContinue
+if ($codehostCmd) { $codehostExe = $codehostCmd.Source }
+elseif (Test-Path (Join-Path $bunBin "codehost.exe")) { $codehostExe = Join-Path $bunBin "codehost.exe" }
+else { Fail "codehost installed but not found in $bunBin. Add it to PATH and run: codehost setup" }
 
 if ($env:CODEHOST_NO_SETUP -eq "1") {
-  Info "installed. Run ``codehost setup`` in the directory you want to serve."
+  Info "installed/updated. Run ``codehost setup`` in the directory you want to serve."
   exit 0
 }
 
 Info "running ``codehost setup``..."
-codehost setup
+& $codehostExe setup

package/public/install.sh

@@ -1,14 +1,22 @@
 #!/bin/sh
-# codehost installer — https://codehost.dev
+# codehost installer / updater — https://codehost.dev
 #
 #   curl -fsSL https://codehost.dev/install.sh | sh
+#   curl -fsSL https://codehost.dev/setup.sh   | sh   # same script, friendlier name
 #
-# Ensures Bun is installed, installs the `codehost` CLI globally (which fetches
-# the native WebRTC binary via Bun's lifecycle scripts), then runs `codehost
-# setup` to pick a token, install VS Code, and start a server daemon.
+# Ensures Bun is installed, installs/UPGRADES the `codehost` CLI globally to the
+# latest release (which fetches the native WebRTC binary via Bun's lifecycle
+# scripts), then runs `codehost setup` to pick a token, install VS Code, and
+# start a server daemon. Safe to re-run any time — it always lands you on the
+# newest codehost.
+#
+# Bun is the runtime (the CLI is TypeScript run by Bun + a native addon), so it
+# can't be skipped — but we bootstrap it and then invoke everything by absolute
+# path, so a not-yet-reloaded shell PATH never makes the install "fail" after
+# Bun is actually present.
 #
 # Env overrides:
-#   CODEHOST_NO_SETUP=1   install only; don't run `codehost setup`
+#   CODEHOST_NO_SETUP=1   install/update only; don't run `codehost setup`
 set -eu
 
 info() { printf '\033[1;36m[codehost]\033[0m %s\n' "$1"; }
@@ -20,7 +28,18 @@ BUN_INSTALL="${BUN_INSTALL:-$HOME/.bun}"
 export BUN_INSTALL
 export PATH="$BUN_INSTALL/bin:$PATH"
 
-if ! command -v bun >/dev/null 2>&1; then
+# Resolve a usable bun binary: one already on PATH, or the managed install.
+# Echoes the absolute path (empty if none) so callers can invoke it directly.
+bun_bin() {
+  if command -v bun >/dev/null 2>&1; then
+    command -v bun
+  elif [ -x "$BUN_INSTALL/bin/bun" ]; then
+    printf '%s\n' "$BUN_INSTALL/bin/bun"
+  fi
+}
+
+BUN="$(bun_bin)"
+if [ -z "$BUN" ]; then
   info "Bun not found — installing from bun.sh…"
   if command -v curl >/dev/null 2>&1; then
     curl -fsSL https://bun.sh/install | bash
@@ -30,26 +49,32 @@ if ! command -v bun >/dev/null 2>&1; then
     err "need curl or wget to install Bun. Install one and re-run."
     exit 1
   fi
-  export PATH="$BUN_INSTALL/bin:$PATH"
+  BUN="$(bun_bin)"
 fi
 
-if ! command -v bun >/dev/null 2>&1; then
-  err "Bun install did not land on PATH. Open a new shell or add $BUN_INSTALL/bin to PATH, then re-run."
+if [ -z "$BUN" ]; then
+  err "Bun was installed but its binary isn't at $BUN_INSTALL/bin/bun. Set BUN_INSTALL to its location and re-run."
   exit 1
 fi
 
-info "installing the codehost CLI (bun add -g codehost)…"
-bun add -g codehost
+# `@latest` makes every re-run an upgrade, so users always end up on the newest
+# codehost instead of a stale globally-pinned copy.
+info "installing the latest codehost CLI ($BUN add -g codehost@latest)…"
+"$BUN" add -g codehost@latest
 
-if ! command -v codehost >/dev/null 2>&1; then
-  err "codehost installed but not on PATH. Add $BUN_INSTALL/bin to your PATH and run: codehost setup"
+CODEHOST="$BUN_INSTALL/bin/codehost"
+if [ ! -x "$CODEHOST" ]; then
+  CODEHOST="$(command -v codehost || true)"
+fi
+if [ -z "$CODEHOST" ] || [ ! -x "$CODEHOST" ]; then
+  err "codehost installed but not found under $BUN_INSTALL/bin. Add it to PATH and run: codehost setup"
   exit 1
 fi
 
 if [ "${CODEHOST_NO_SETUP:-}" = "1" ]; then
-  info "installed. Run \`codehost setup\` in the directory you want to serve."
+  info "installed/updated. Run \`codehost setup\` in the directory you want to serve."
   exit 0
 fi
 
 info "running \`codehost setup\`…"
-exec codehost setup
+exec "$CODEHOST" setup

package/src/cli/commands/dev.ts

@@ -8,6 +8,7 @@ import { announceConnect } from "../open-url";
 import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
 import { repoIdentity } from "../git";
+import { toPosixPath } from "../../shared/repo";
 import { DEFAULT_SIGNAL_URL } from "./serve";
 
 interface DevArgs {
@@ -85,7 +86,9 @@ export const devCommand: CommandModule<{}, DevArgs> = {
     const id = repoIdentity(dir);
     const meta: PeerMeta = {
       name: argv.name ?? host,
-      cwd: dir,
+      // POSIX-drive 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",
       repo: id.repo,

package/src/cli/commands/serve.ts

@@ -2,7 +2,7 @@ import { hostname } from "node:os";
 import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
-import { DEFAULT_LAYOUT } from "../../shared/repo";
+import { DEFAULT_LAYOUT, toPosixPath } from "../../shared/repo";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
 import { launchServeDaemon } from "../daemonize";
 import { announceConnect } from "../open-url";
@@ -87,7 +87,9 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     // onto subfolders via VS Code's ?folder= using this layout.
     const meta: PeerMeta = {
       name: argv.name ?? host,
-      cwd: dir,
+      // POSIX-drive form for the browser ?folder= URI (C:\ws -> /c/ws); the real
+      // OS path `dir` is still what we spawn VS Code in.
+      cwd: toPosixPath(dir),
       host,
       kind: "root",
       layout: DEFAULT_LAYOUT,

package/src/cli/daemonize.ts

@@ -1,4 +1,5 @@
 import { daemonName, startDaemon } from "./oxmgr";
+import { selfUpdate } from "./self-update";
 
 export interface ServeDaemonOptions {
   /** Subcommand to re-launch under oxmgr. */
@@ -31,6 +32,11 @@ export interface ServeDaemonResult {
  * the shell and restarts on failure. 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
+  // the fresh daemon runs the latest code. startDaemon does delete+start, so a
+  // re-launch replaces any live daemon with the updated one. Non-fatal.
+  await selfUpdate();
+
   const label = opts.name ?? opts.dir.split("/").pop() ?? opts.host;
   const name = daemonName(label);
   const command = buildForegroundCommand(opts);

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

package/src/shared/repo.ts

@@ -52,6 +52,25 @@ export function repoKey(t: Pick<RepoTarget, "owner" | "name">): string {
   return `gh/${t.owner}/${t.name}`;
 }
 
+/**
+ * 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.
+ */
+export function toPosixPath(p: string): string {
+  const drive = /^([A-Za-z]):(?:[\\/](.*))?$/.exec(p);
+  if (drive) {
+    const letter = drive[1].toLowerCase();
+    const rest = (drive[2] ?? "").replace(/\\/g, "/").replace(/\/+$/, "");
+    return rest ? `/${letter}/${rest}` : `/${letter}`;
+  }
+  // Already POSIX (or a relative path): just unify any stray backslashes.
+  return p.replace(/\\/g, "/");
+}
+
 /** Fill a layout template from a repo target (default branch -> "main"). */
 export function fillLayout(layout: string, t: RepoTarget): string {
   return layout