codehost 0.1.0 → 0.3.1

package/src/cli/commands/expose.ts

@@ -0,0 +1,93 @@
+import { hostname } from "node:os";
+import type { CommandModule } from "yargs";
+import type { PeerMeta } from "../../shared/signaling";
+import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { launchServeDaemon } from "../daemonize";
+import { runServer } from "../run-server";
+import { DEFAULT_SIGNAL_URL } from "./serve";
+
+interface ExposeArgs {
+  port: number;
+  token: string;
+  name?: string;
+  signal: string;
+  daemon: boolean;
+}
+
+export const exposeCommand: CommandModule<{}, ExposeArgs> = {
+  command: "expose <port>",
+  describe:
+    "Tunnel an existing local HTTP/WS server (any port) over WebRTC — reachable at codehost.dev/vs/<peerId>/",
+  builder: (y) =>
+    y
+      .positional("port", {
+        describe: "Local port to expose (e.g. 7432)",
+        type: "number",
+        demandOption: true,
+      })
+      .option("token", {
+        alias: "t",
+        describe: "Room token shared with the codehost.dev page",
+        type: "string",
+        demandOption: true,
+      })
+      .option("name", {
+        describe: "Display name for this server (defaults to localhost:<port>)",
+        type: "string",
+      })
+      .option("signal", {
+        describe: "Signaling server URL",
+        type: "string",
+        default: DEFAULT_SIGNAL_URL,
+      })
+      .option("daemon", {
+        alias: "d",
+        describe: "Run in the background under oxmgr (auto-starts on login)",
+        type: "boolean",
+        default: false,
+      }) as any,
+  handler: async (argv) => {
+    argv.token = argv.token.trim();
+    const check = validateToken(argv.token);
+    if (!check.ok) {
+      console.error(`[codehost] ${check.reason}`);
+      console.error(`[codehost] room token requires: ${TOKEN_REQUIREMENTS}`);
+      process.exit(1);
+    }
+    if (!Number.isInteger(argv.port) || argv.port <= 0 || argv.port > 65535) {
+      console.error(`[codehost] invalid port: ${argv.port}`);
+      process.exit(1);
+    }
+
+    const host = hostname();
+
+    if (argv.daemon) {
+      const { ok } = await launchServeDaemon({
+        command: "expose",
+        dir: process.cwd(),
+        arg: String(argv.port),
+        token: argv.token,
+        signal: argv.signal,
+        name: argv.name,
+        host,
+      });
+      process.exit(ok ? 0 : 1);
+    }
+
+    const meta: PeerMeta = {
+      name: argv.name ?? `localhost:${argv.port}`,
+      cwd: `localhost:${argv.port}`,
+      host,
+    };
+
+    // No VS Code: tunnel directly to the given port, stripping the /vs/<peerId>
+    // prefix the server doesn't know about.
+    await runServer({
+      token: argv.token,
+      signal: argv.signal,
+      meta,
+      label: `exposing localhost:${argv.port}`,
+      launch: async (basePath) => ({ port: argv.port, stripBasePath: basePath }),
+    });
+  },
+};

package/src/cli/commands/list.ts

@@ -5,7 +5,7 @@ export const listCommand: CommandModule = {
   command: "list",
   aliases: ["ls"],
   describe: "List codehost servers running under oxmgr",
-  handler: () => {
-    process.exit(listDaemons());
+  handler: async () => {
+    process.exit(await listDaemons());
   },
 };

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 { launchServeDaemon } from "../daemonize";
+import { announceConnect } from "../open-url";
+import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
-import { Tunnel } from "../tunnel";
-import { daemonName, startDaemon } from "../oxmgr";
 
 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,88 +67,42 @@ 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 label = argv.name ?? dir.split("/").pop() ?? host;
-      const name = daemonName(label);
-      const command = buildForegroundCommand(dir, argv);
-      console.log(`[codehost] starting daemon "${name}" via oxmgr`);
-      const ok = startDaemon({ name, command, cwd: dir });
-      if (ok) {
-        console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
-        process.exit(0);
-      }
-      process.exit(1);
+      const { ok } = await launchServeDaemon({
+        command: "serve",
+        dir,
+        token: argv.token,
+        signal: argv.signal,
+        name: argv.name,
+        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>(() => {});
   },
 };
-
-/**
- * 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`.
- */
-function buildForegroundCommand(dir: string, argv: ServeArgs): string {
-  const parts = [process.execPath, process.argv[1], "serve", dir, "-t", argv.token, "--signal", argv.signal];
-  if (argv.name) parts.push("--name", argv.name);
-  if (argv.port) parts.push("--port", String(argv.port));
-  return parts.map(quote).join(" ");
-}
-
-function quote(s: string): string {
-  return /[^A-Za-z0-9_\/:=.-]/.test(s) ? `'${s.replace(/'/g, `'\\''`)}'` : s;
-}

package/src/cli/commands/setup.ts

@@ -0,0 +1,99 @@
+import { hostname } from "node:os";
+import { resolve } from "node:path";
+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";
+
+interface SetupArgs {
+  dir: string;
+  token?: string;
+  newToken: boolean;
+  name?: string;
+  signal: string;
+  port?: number;
+}
+
+export const setupCommand: CommandModule<{}, SetupArgs> = {
+  command: "setup [dir]",
+  describe: "One-shot: pick a token, ensure VS Code, and start a daemonized server",
+  builder: (y) =>
+    y
+      .positional("dir", { describe: "Directory to serve (defaults to cwd)", type: "string", default: "." })
+      .option("token", {
+        alias: "t",
+        describe: "Room token (generated + saved if omitted)",
+        type: "string",
+      })
+      .option("new-token", {
+        describe: "Generate a fresh token even if one is saved",
+        type: "boolean",
+        default: false,
+      })
+      .option("name", { describe: "Display name for this server (defaults to hostname)", type: "string" })
+      .option("signal", { describe: "Signaling server URL", type: "string", default: DEFAULT_SIGNAL_URL })
+      .option("port", { describe: "Fixed port for the local VS Code server", type: "number" }) as any,
+  handler: async (argv) => {
+    const dir = resolve(process.cwd(), argv.dir);
+    const host = hostname();
+
+    // 1. Resolve the room token: validate an explicit one, otherwise reuse the
+    //    saved token (stable room URL) or mint and persist a strong new one.
+    const token = resolveToken(argv);
+    console.log(`[codehost] room token: ${token}`);
+
+    // 2. Make sure a working VS Code is available, installing/upgrading the
+    //    managed CLI if the system `code` is missing or broken. Doing it here
+    //    surfaces download progress before we hand off to the daemon.
+    console.log("[codehost] checking VS Code…");
+    const codeBin = await resolveCodeBinary();
+    console.log(`[codehost] using VS Code: ${codeBin}`);
+
+    // 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,
+      name: argv.name,
+      port: argv.port,
+      host,
+    });
+    if (!ok) process.exit(1);
+
+    // 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}`);
+    announceConnect(token);
+    console.log(`[codehost] manage it with: codehost list · codehost stop ${name}`);
+  },
+};
+
+function resolveToken(argv: SetupArgs): string {
+  if (argv.token) {
+    const t = argv.token.trim();
+    const check = validateToken(t);
+    if (!check.ok) {
+      console.error(`[codehost] ${check.reason}`);
+      console.error(`[codehost] room token requires: ${TOKEN_REQUIREMENTS}`);
+      process.exit(1);
+    }
+    // Persist an explicit token too, so later `setup` runs reuse the same room.
+    writeConfig({ ...readConfig(), token: t });
+    return t;
+  }
+
+  const config = readConfig();
+  if (config.token && !argv.newToken) return config.token;
+
+  const token = generateToken();
+  writeConfig({ ...config, token });
+  console.log("[codehost] generated a new room token (saved to ~/.codehost/config.json)");
+  return token;
+}

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

@@ -0,0 +1,19 @@
+import type { CommandModule } from "yargs";
+import { resolveCodeBinary } from "../vscode-install";
+
+export const updateCommand: CommandModule = {
+  command: "update",
+  describe: "Download the latest VS Code CLI now (ignores the daily check throttle)",
+  handler: async () => {
+    if (process.env.CODEHOST_CODE_BIN) {
+      console.log(`[codehost] CODEHOST_CODE_BIN is set; nothing to update (${process.env.CODEHOST_CODE_BIN})`);
+      return;
+    }
+    if (Bun.which("code")) {
+      console.log("[codehost] using system `code` on PATH; update it with your package manager.");
+      return;
+    }
+    const bin = await resolveCodeBinary({ force: true });
+    console.log(`[codehost] up to date: ${bin}`);
+  },
+};

package/src/cli/config.ts

@@ -0,0 +1,27 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// Persistent CLI config under ~/.codehost (same root as the managed VS Code
+// cache in vscode-install.ts). Currently just the reusable room token so
+// `codehost setup` lands on a stable room URL across runs.
+
+const CONFIG_FILE = join(homedir(), ".codehost", "config.json");
+
+export interface CliConfig {
+  /** Room token reused by `setup` until --new-token or an explicit -t. */
+  token?: string;
+}
+
+export function readConfig(): CliConfig {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf8")) as CliConfig;
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfig(config: CliConfig): void {
+  mkdirSync(dirname(CONFIG_FILE), { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/src/cli/daemonize.ts

@@ -0,0 +1,59 @@
+import { daemonName, startDaemon } from "./oxmgr";
+
+export interface ServeDaemonOptions {
+  /** 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. */
+  signal: string;
+  /** Display name; also seeds the oxmgr process label. */
+  name?: string;
+  /** Fixed local VS Code port. */
+  port?: number;
+  /** Hostname, used as a label fallback. */
+  host: string;
+}
+
+export interface ServeDaemonResult {
+  ok: boolean;
+  /** oxmgr process name this server was registered under. */
+  name: string;
+}
+
+/**
+ * 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 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 = await startDaemon({ name, command, cwd: opts.dir });
+  if (ok) {
+    console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
+  }
+  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`.
+ */
+function buildForegroundCommand(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(" ");
+}
+
+function quote(s: string): string {
+  return /[^A-Za-z0-9_\/:=.-]/.test(s) ? `'${s.replace(/'/g, `'\\''`)}'` : s;
+}

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

@@ -1,16 +1,24 @@
 #!/usr/bin/env bun
 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";
 
 yargs(hideBin(process.argv))
   .scriptName("codehost")
   .usage("$0 <command> [options]")
+  .command(setupCommand)
   .command(serveCommand)
+  .command(devCommand)
+  .command(exposeCommand)
   .command(listCommand)
   .command(stopCommand)
+  .command(updateCommand)
   .demandCommand(1, "Specify a command, e.g. `codehost serve`")
   .strict()
   .help()

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