codehost 0.1.1 → 0.4.0

package/src/cli/commands/dev.ts

@@ -0,0 +1,110 @@
+import { hostname } from "node:os";
+import { resolve } from "node:path";
+import type { CommandModule } from "yargs";
+import type { PeerMeta } from "../../shared/signaling";
+import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { launchServeDaemon } from "../daemonize";
+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 {
+  dir: string;
+  token: string;
+  name?: string;
+  signal: string;
+  daemon: boolean;
+  port?: number;
+}
+
+export const devCommand: CommandModule<{}, DevArgs> = {
+  command: "dev [dir]",
+  describe:
+    "Serve a single folder over WebRTC; open it at codehost.dev/dev/<path> (or /gh/<owner>/<repo> when it's a GitHub repo)",
+  builder: (y) =>
+    y
+      .positional("dir", {
+        describe: "Directory to serve (defaults to cwd)",
+        type: "string",
+        default: ".",
+      })
+      .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 hostname)",
+        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,
+      })
+      .option("port", {
+        describe: "Fixed port for the local VS Code server (default: ephemeral)",
+        type: "number",
+      }) 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);
+    }
+
+    const dir = resolve(process.cwd(), argv.dir);
+    const host = hostname();
+
+    if (argv.daemon) {
+      const { ok } = await launchServeDaemon({
+        command: "dev",
+        dir,
+        token: argv.token,
+        signal: argv.signal,
+        name: argv.name,
+        port: argv.port,
+        host,
+      });
+      if (ok) announceConnect(argv.token);
+      process.exit(ok ? 0 : 1);
+    }
+
+    // A single folder: git-identified so GitHub deep links resolve to it.
+    const id = repoIdentity(dir);
+    const meta: PeerMeta = {
+      name: argv.name ?? host,
+      // 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,
+      branch: id.branch,
+    };
+
+    announceConnect(argv.token);
+    await runServer({
+      token: argv.token,
+      signal: argv.signal,
+      meta,
+      label: `serving ${dir}`,
+      launch: async (basePath) => {
+        const v = await launchVscode({ dir, basePath, port: argv.port });
+        return { port: v.port, stop: v.stop };
+      },
+    });
+  },
+};

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, toPosixPath } 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,32 @@ 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,
+      // 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,
+    };
 
-    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,14 @@
 import { daemonName, startDaemon } from "./oxmgr";
+import { selfUpdate } from "./self-update";
 
 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 +31,17 @@ 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> {
+  // 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);
   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 +54,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);
+  }
+}