codehost 0.1.1 → 0.3.1

package/src/cli/commands/serve.ts

@@ -1,13 +1,13 @@
 import { hostname } from "node:os";
 import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
-import { type PeerMeta, newPeerId } from "../../shared/signaling";
+import type { PeerMeta } from "../../shared/signaling";
+import { DEFAULT_LAYOUT } from "../../shared/repo";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
-import { SignalingClient } from "../../shared/signaling-client";
-import { RtcDaemon } from "../rtc-daemon";
-import { launchVscode } from "../vscode";
-import { Tunnel } from "../tunnel";
 import { launchServeDaemon } from "../daemonize";
+import { announceConnect } from "../open-url";
+import { runServer } from "../run-server";
+import { launchVscode } from "../vscode";
 
 export const DEFAULT_SIGNAL_URL = "wss://signal.codehost.dev";
 
@@ -22,7 +22,8 @@ interface ServeArgs {
 
 export const serveCommand: CommandModule<{}, ServeArgs> = {
   command: "serve [dir]",
-  describe: "Serve VS Code from a directory and peer it to codehost.dev over WebRTC",
+  describe:
+    "Serve a workspace root over WebRTC; repos under it open via codehost.dev/gh/<owner>/<repo>",
   builder: (y) =>
     y
       .positional("dir", {
@@ -47,7 +48,7 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
       })
       .option("daemon", {
         alias: "d",
-        describe: "Run in the background under oxmgr",
+        describe: "Run in the background under oxmgr (auto-starts on login)",
         type: "boolean",
         default: false,
       })
@@ -66,15 +67,11 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
 
     const dir = resolve(process.cwd(), argv.dir);
     const host = hostname();
-    const meta: PeerMeta = {
-      name: argv.name ?? host,
-      cwd: dir,
-      host,
-    };
 
     // `-d`: re-launch this same `serve` (without -d) under oxmgr, then exit.
     if (argv.daemon) {
-      const { ok } = launchServeDaemon({
+      const { ok } = await launchServeDaemon({
+        command: "serve",
         dir,
         token: argv.token,
         signal: argv.signal,
@@ -82,55 +79,30 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
         port: argv.port,
         host,
       });
+      if (ok) announceConnect(argv.token);
       process.exit(ok ? 0 : 1);
     }
 
-    // peerId is fixed up front so VS Code can be mounted under /vs/<peerId>,
-    // which the browser Service Worker uses to route requests to this daemon.
-    const peerId = newPeerId();
-    const basePath = `/vs/${peerId}`;
-
-    console.log(`[codehost] serving ${dir}`);
-    console.log(`[codehost] room token: ${argv.token}`);
-    console.log(`[codehost] signaling:  ${argv.signal}`);
-
-    const vscode = await launchVscode({ dir, basePath, port: argv.port });
-
-    let rtc: RtcDaemon;
+    // A workspace root: repos under it open by GitHub-shaped deep link, mapped
+    // onto subfolders via VS Code's ?folder= using this layout.
+    const meta: PeerMeta = {
+      name: argv.name ?? host,
+      cwd: dir,
+      host,
+      kind: "root",
+      layout: DEFAULT_LAYOUT,
+    };
 
-    const client = new SignalingClient({
-      url: argv.signal,
+    announceConnect(argv.token);
+    await runServer({
       token: argv.token,
-      role: "server",
-      peerId,
+      signal: argv.signal,
       meta,
-      onOpen: () => console.log(`[codehost] registered as "${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),
-      // Each viewer's data channel is bridged to the local VS Code server.
-      onChannel: (viewerId, channel) => {
-        console.log(`[codehost] viewer ${viewerId.slice(0, 8)} connected; bridging to VS Code`);
-        new Tunnel(channel, vscode.port);
+      label: `serving workspace root ${dir}`,
+      launch: async (basePath) => {
+        const v = await launchVscode({ dir, basePath, port: argv.port });
+        return { port: v.port, stop: v.stop };
       },
     });
-
-    client.connect();
-
-    const shutdown = () => {
-      console.log("\n[codehost] shutting down");
-      rtc.closeAll();
-      client.close();
-      vscode.stop();
-      process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-
-    // Keep the process alive.
-    await new Promise<never>(() => {});
   },
 };

package/src/cli/commands/setup.ts

@@ -4,11 +4,11 @@ import type { CommandModule } from "yargs";
 import { generateToken, validateToken, TOKEN_REQUIREMENTS } from "../../shared/token";
 import { readConfig, writeConfig } from "../config";
 import { launchServeDaemon } from "../daemonize";
+import { isGitRepo } from "../git";
 import { resolveCodeBinary } from "../vscode-install";
+import { announceConnect } from "../open-url";
 import { DEFAULT_SIGNAL_URL } from "./serve";
 
-const PAGE_URL = "https://codehost.dev";
-
 interface SetupArgs {
   dir: string;
   token?: string;
@@ -53,8 +53,10 @@ export const setupCommand: CommandModule<{}, SetupArgs> = {
     const codeBin = await resolveCodeBinary();
     console.log(`[codehost] using VS Code: ${codeBin}`);
 
-    // 3. Start the WebRTC + VS Code server under oxmgr.
-    const { ok, name } = launchServeDaemon({
+    // 3. Start the WebRTC + VS Code server under oxmgr. A git repo is a single
+    //    workspace (`dev`); anything else is treated as a root (`serve`).
+    const { ok, name } = await launchServeDaemon({
+      command: isGitRepo(dir) ? "dev" : "serve",
       dir,
       token,
       signal: argv.signal,
@@ -64,10 +66,11 @@ export const setupCommand: CommandModule<{}, SetupArgs> = {
     });
     if (!ok) process.exit(1);
 
-    // 4. Tell the user how to connect.
+    // 4. Tell the user how to connect, and open the browser straight at the
+    //    token-carrying URL so VS Code loads without typing the token in.
     console.log("");
     console.log(`[codehost] ✓ server "${name}" is live, serving ${dir}`);
-    console.log(`[codehost] open ${PAGE_URL} and enter your token to connect.`);
+    announceConnect(token);
     console.log(`[codehost] manage it with: codehost list · codehost stop ${name}`);
   },
 };

package/src/cli/commands/stop.ts

@@ -14,7 +14,7 @@ export const stopCommand: CommandModule<{}, StopArgs> = {
       type: "string",
       demandOption: true,
     }) as any,
-  handler: (argv) => {
-    process.exit(stopDaemon(argv.name));
+  handler: async (argv) => {
+    process.exit(await stopDaemon(argv.name));
   },
 };

package/src/cli/daemonize.ts

@@ -1,8 +1,13 @@
 import { daemonName, startDaemon } from "./oxmgr";
 
 export interface ServeDaemonOptions {
-  /** Absolute directory to serve. */
+  /** Subcommand to re-launch under oxmgr. */
+  command?: "serve" | "dev" | "expose";
+  /** Absolute directory to serve (also the oxmgr working dir). */
   dir: string;
+  /** Positional argument for the re-launched command (defaults to `dir`); for
+   *  `expose` this is the port, while `dir` stays a real cwd for oxmgr. */
+  arg?: string;
   /** Room token (already validated). */
   token: string;
   /** Signaling server URL. */
@@ -25,12 +30,12 @@ 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`.
  */
-export function launchServeDaemon(opts: ServeDaemonOptions): ServeDaemonResult {
+export async function launchServeDaemon(opts: ServeDaemonOptions): Promise<ServeDaemonResult> {
   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 = startDaemon({ name, command, cwd: opts.dir });
+  const ok = await startDaemon({ name, command, cwd: opts.dir });
   if (ok) {
     console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
   }
@@ -43,7 +48,7 @@ export function launchServeDaemon(opts: ServeDaemonOptions): ServeDaemonResult {
  * for `bunx codehost` and local `bun src/cli/index.ts`.
  */
 function buildForegroundCommand(opts: ServeDaemonOptions): string {
-  const parts = [process.execPath, process.argv[1], "serve", opts.dir, "-t", opts.token, "--signal", opts.signal];
+  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(" ");

package/src/cli/git.ts

@@ -0,0 +1,53 @@
+import { spawnSync } from "node:child_process";
+
+// Derive a normalized repo identity ("gh/<owner>/<repo>") + branch from a git
+// working tree, so a `codehost dev` daemon can be addressed by GitHub-shaped
+// deep links. Best-effort: returns undefined fields off git / off GitHub.
+
+export interface RepoIdentity {
+  /** Normalized identity, e.g. "gh/snomiao/codehost". */
+  repo?: string;
+  /** Current branch, e.g. "main". */
+  branch?: string;
+}
+
+/** True if `dir` is inside a git working tree (has a resolvable .git). */
+export function isGitRepo(dir: string): boolean {
+  const r = git(dir, ["rev-parse", "--is-inside-work-tree"]);
+  return r.trim() === "true";
+}
+
+export function repoIdentity(dir: string): RepoIdentity {
+  if (!isGitRepo(dir)) return {};
+  const remote =
+    git(dir, ["remote", "get-url", "origin"]) || git(dir, ["config", "--get", "remote.origin.url"]);
+  const branch =
+    git(dir, ["rev-parse", "--abbrev-ref", "HEAD"]) || git(dir, ["symbolic-ref", "--short", "HEAD"]);
+  return {
+    repo: parseGitHubRemote(remote),
+    branch: branch && branch !== "HEAD" ? branch : undefined,
+  };
+}
+
+/**
+ * Parse a GitHub remote URL into "gh/<owner>/<repo>". Handles:
+ *   https://github.com/owner/repo(.git)
+ *   git@github.com:owner/repo(.git)
+ *   ssh://git@github.com/owner/repo(.git)
+ * Returns undefined for non-GitHub or unparseable remotes.
+ */
+export function parseGitHubRemote(url: string): string | undefined {
+  const u = url.trim();
+  if (!u) return undefined;
+  const m = u.match(/github\.com[/:]([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+  if (!m) return undefined;
+  const owner = m[1];
+  const repo = m[2];
+  if (!owner || !repo) return undefined;
+  return `gh/${owner}/${repo}`;
+}
+
+function git(dir: string, args: string[]): string {
+  const r = spawnSync("git", ["-C", dir, ...args], { encoding: "utf8" });
+  return r.status === 0 ? (r.stdout ?? "").trim() : "";
+}

package/src/cli/index.ts

@@ -3,6 +3,8 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { setupCommand } from "./commands/setup";
 import { serveCommand } from "./commands/serve";
+import { devCommand } from "./commands/dev";
+import { exposeCommand } from "./commands/expose";
 import { listCommand } from "./commands/list";
 import { stopCommand } from "./commands/stop";
 import { updateCommand } from "./commands/update";
@@ -12,6 +14,8 @@ yargs(hideBin(process.argv))
   .usage("$0 <command> [options]")
   .command(setupCommand)
   .command(serveCommand)
+  .command(devCommand)
+  .command(exposeCommand)
   .command(listCommand)
   .command(stopCommand)
   .command(updateCommand)

package/src/cli/open-url.ts

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+
+/** Public codehost page that brokers the WebRTC handshake. */
+export const PAGE_URL = "https://codehost.dev";
+
+/**
+ * Build the auto-connect URL for a room token. The token rides in the URL
+ * *fragment* (`#t=<token>`) on purpose: the page is a static asset, so the
+ * fragment never leaves the browser — it isn't sent to Cloudflare, nor written
+ * to access logs or `Referer` headers. The page reads it, fills the token, and
+ * auto-connects when a single server is live.
+ */
+export function connectUrl(token: string, page: string = PAGE_URL): string {
+  return `${page}/#t=${encodeURIComponent(token)}`;
+}
+
+/** Open `url` in the default browser. Best-effort, cross-platform, detached. */
+export function openBrowser(url: string): void {
+  try {
+    if (process.platform === "win32") {
+      // `start` is a cmd builtin; the empty "" is the (ignored) window title so
+      // a quoted URL isn't mistaken for one.
+      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true, windowsHide: true }).unref();
+    } else if (process.platform === "darwin") {
+      spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+    } else {
+      spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+    }
+  } catch {
+    // best-effort; the URL is always printed too.
+  }
+}
+
+/**
+ * Print the connect URL and, in an interactive terminal, open it in the
+ * browser. The TTY guard keeps the oxmgr-spawned daemon (which re-runs
+ * `serve`/`dev` in the foreground with no TTY) from popping a tab on every
+ * restart — it just logs the URL.
+ */
+export function announceConnect(token: string, page: string = PAGE_URL): void {
+  const url = connectUrl(token, page);
+  console.log(`[codehost] connect: ${url}`);
+  if (process.stdout.isTTY) {
+    console.log("[codehost] opening your browser…");
+    openBrowser(url);
+  }
+}

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;
+}