codehost 0.1.0 → 0.3.1

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/rtc-daemon.ts

@@ -1,3 +1,5 @@
+import { spawnSync } from "node:child_process";
+import { dirname } from "node:path";
 import { createRequire } from "node:module";
 import type {
   DataChannel,
@@ -10,7 +12,61 @@ import { ICE_SERVERS, type RtcSignal } from "../shared/rtc";
 // resolves correctly from the project's node_modules. So load it via require;
 // the `import type` above is erased at build time and triggers no runtime load.
 const require = createRequire(import.meta.url);
-const ndc = require("node-datachannel") as typeof import("node-datachannel");
+const ndc = loadNodeDataChannel();
+
+/**
+ * Load the native node-datachannel addon, self-healing the common failure where
+ * its prebuilt `.node` was never fetched. That happens under `bunx codehost`:
+ * bunx skips install lifecycle scripts (and `trustedDependencies` only applies
+ * to `bun install`), so node-datachannel's `install` step — which downloads the
+ * binary via `prebuild-install` — never runs. On the first load failure we run
+ * that prebuild-install ourselves, then retry. A normal `bun add -g` install
+ * already has the binary, so this is a no-op there.
+ */
+function loadNodeDataChannel(): typeof import("node-datachannel") {
+  try {
+    return require("node-datachannel") as typeof import("node-datachannel");
+  } catch (firstErr) {
+    if (!fetchNodeDataChannelBinary()) throw nativeLoadError(firstErr);
+    try {
+      return require("node-datachannel") as typeof import("node-datachannel");
+    } catch (secondErr) {
+      throw nativeLoadError(secondErr);
+    }
+  }
+}
+
+/** Run node-datachannel's bundled `prebuild-install` to fetch the prebuilt
+ *  binary. Returns true if it exited cleanly. */
+function fetchNodeDataChannelBinary(): boolean {
+  let pkgDir: string;
+  let prebuildBin: string;
+  try {
+    pkgDir = dirname(require.resolve("node-datachannel/package.json"));
+    // prebuild-install is a dependency of node-datachannel; resolve its CLI
+    // entry from the package's own module scope.
+    prebuildBin = require.resolve("prebuild-install/bin.js", { paths: [pkgDir] });
+  } catch {
+    return false;
+  }
+  console.log("[codehost] fetching node-datachannel native binary (prebuild-install)…");
+  const r = spawnSync(process.execPath, [prebuildBin, "-r", "napi"], {
+    cwd: pkgDir,
+    stdio: "inherit",
+  });
+  return r.status === 0;
+}
+
+function nativeLoadError(cause: unknown): Error {
+  return new Error(
+    "Failed to load the native WebRTC module (node-datachannel). Its prebuilt " +
+      "binary could not be fetched automatically. Install codehost globally so " +
+      "install scripts run — `bun add -g codehost` (or `npm i -g codehost`) — " +
+      "and ensure network access. If your platform has no prebuilt, a C++ " +
+      "toolchain + cmake is needed to build from source. " +
+      `(cause: ${(cause as Error)?.message ?? cause})`,
+  );
+}
 
 export interface RtcDaemonOptions {
   /** Relay a signal to a viewer peer via the signaling channel. */

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