codehost 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.7.0](https://github.com/snomiao/codehost/compare/v0.6.0...v0.7.0) (2026-06-08)
+
+
+### Features
+
+* add 'ch' bin alias for codehost CLI ([b66983d](https://github.com/snomiao/codehost/commit/b66983dd4d56073a9b1e8257eaf858440249968a))
+
+# [0.6.0](https://github.com/snomiao/codehost/compare/v0.5.1...v0.6.0) (2026-06-08)
+
+
+### Features
+
+* detached fallback daemon when oxmgr is unavailable ([3aeddad](https://github.com/snomiao/codehost/commit/3aeddad595a2fc65f8a65050a5cc6171f41bca8f))
+
 ## [0.5.1](https://github.com/snomiao/codehost/compare/v0.5.0...v0.5.1) (2026-06-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -9,7 +9,8 @@
   "homepage": "https://codehost.dev",
   "bugs": "https://github.com/snomiao/codehost/issues",
   "bin": {
-    "codehost": "./src/cli/index.ts"
+    "codehost": "./src/cli/index.ts",
+    "ch": "./src/cli/index.ts"
   },
   "scripts": {
     "dev": "concurrently \"bun run dev:server\" \"vite --port 5173\"",

package/src/cli/commands/list.ts

@@ -1,11 +1,26 @@
 import type { CommandModule } from "yargs";
-import { listDaemons } from "../oxmgr";
+import { hasOxmgr, listDaemons } from "../oxmgr";
+import { listFallbackDaemons } from "../fallback-daemon";
 
 export const listCommand: CommandModule = {
   command: "list",
   aliases: ["ls"],
-  describe: "List codehost servers running under oxmgr",
+  describe: "List codehost servers (oxmgr-managed and detached)",
   handler: async () => {
-    process.exit(await listDaemons());
+    const detached = listFallbackDaemons();
+    if (detached.length) {
+      console.log("Detached daemons (no oxmgr):");
+      for (const d of detached) {
+        console.log(`  ${d.name}  pid ${d.pid}  ${d.cwd}  (log: ${d.log})`);
+      }
+      console.log("");
+    }
+    // Only hit oxmgr if it's actually runnable — `hasOxmgr` doesn't self-heal,
+    // so a broken install won't re-download its binary on every `list`.
+    if (await hasOxmgr()) {
+      process.exit(await listDaemons());
+    }
+    if (!detached.length) console.log("No codehost daemons running.");
+    process.exit(0);
   },
 };

package/src/cli/commands/stop.ts

@@ -1,5 +1,6 @@
 import type { CommandModule } from "yargs";
-import { stopDaemon } from "../oxmgr";
+import { daemonName, stopDaemon } from "../oxmgr";
+import { stopFallbackDaemon } from "../fallback-daemon";
 
 interface StopArgs {
   name: string;
@@ -15,6 +16,13 @@ export const stopCommand: CommandModule<{}, StopArgs> = {
       demandOption: true,
     }) as any,
   handler: async (argv) => {
+    // Detached daemons are tracked locally; check those first so we don't poke
+    // (and possibly re-download) oxmgr when it isn't even managing this one.
+    const full = argv.name.startsWith("codehost-") ? argv.name : daemonName(argv.name);
+    if (stopFallbackDaemon(full) || stopFallbackDaemon(argv.name)) {
+      console.log(`[codehost] stopped ${full}`);
+      process.exit(0);
+    }
     process.exit(await stopDaemon(argv.name));
   },
 };

package/src/cli/commands/supervise.ts

@@ -0,0 +1,24 @@
+import type { CommandModule } from "yargs";
+import { runSupervisor } from "../fallback-daemon";
+
+interface SuperviseArgs {
+  name: string;
+  argv: string;
+}
+
+// Hidden internal command: the supervisor process behind a detached fallback
+// daemon (see fallback-daemon.ts). Not meant to be run by hand — `serve -d` /
+// `setup` spawn it when oxmgr isn't available.
+export const superviseCommand: CommandModule<{}, SuperviseArgs> = {
+  command: "__supervise",
+  describe: false, // hidden from help
+  builder: (y) =>
+    y
+      .option("name", { type: "string", demandOption: true })
+      .option("argv", { type: "string", demandOption: true, describe: "JSON-encoded serve argv" }) as any,
+  handler: async (a) => {
+    const argv = JSON.parse(a.argv) as string[];
+    const code = await runSupervisor(a.name, argv);
+    process.exit(code);
+  },
+};

package/src/cli/daemonize.ts

@@ -1,5 +1,6 @@
 import { daemonName, startDaemon } from "./oxmgr";
 import { selfUpdate } from "./self-update";
+import { startFallbackDaemon } from "./fallback-daemon";
 
 export interface ServeDaemonOptions {
   /** Subcommand to re-launch under oxmgr. */
@@ -28,8 +29,11 @@ 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`.
+ * Launch a foreground `codehost serve` (without -d) so it survives the shell and
+ * restarts on failure. Prefers oxmgr (which also adds login auto-start); when
+ * oxmgr can't run here (e.g. broken native binary on Windows) it falls back to a
+ * detached, self-restarting child instead of failing. `CODEHOST_NO_OXMGR=1`
+ * forces the fallback. 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
@@ -39,25 +43,39 @@ export async function launchServeDaemon(opts: ServeDaemonOptions): Promise<Serve
 
   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 });
+  const argv = buildForegroundArgv(opts);
+
+  if (process.env.CODEHOST_NO_OXMGR !== "1") {
+    console.log(`[codehost] starting daemon "${name}" via oxmgr`);
+    // startDaemon attempts to self-heal oxmgr once; false means it's unusable here.
+    const ok = await startDaemon({ name, command: argv.map(quote).join(" "), cwd: opts.dir });
+    if (ok) {
+      console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
+      return { ok: true, name };
+    }
+    console.warn("[codehost] oxmgr unavailable — falling back to a detached daemon (no login auto-start).");
+  }
+
+  const ok = startFallbackDaemon({ name, argv, cwd: opts.dir });
   if (ok) {
-    console.log(`[codehost] daemon started. View: codehost list · Stop: codehost stop ${name}`);
+    console.log(`[codehost] detached daemon "${name}" started. View: codehost list · Stop: codehost stop ${name}`);
+  } else {
+    console.error("[codehost] failed to start a detached daemon.");
   }
   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`.
+ * Reconstruct the exact foreground `serve` invocation (without -d) as an argv
+ * array. Uses the same runtime + entry script that launched us, so it works both
+ * for `bunx codehost` and local `bun src/cli/index.ts`. oxmgr takes a shell
+ * string (we quote+join); the fallback spawns the argv directly.
  */
-function buildForegroundCommand(opts: ServeDaemonOptions): string {
+function buildForegroundArgv(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(" ");
+  return parts;
 }
 
 function quote(s: string): string {

package/src/cli/fallback-daemon.ts

@@ -0,0 +1,139 @@
+import { spawn, type Subprocess } from "bun";
+import { mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// A minimal, non-oxmgr daemon manager: a detached, self-restarting child that
+// survives the shell. Used as a fallback when oxmgr's native binary can't run
+// here (e.g. broken on a Windows box) so `-d`/`setup` still leave a running
+// server instead of failing or re-download-looping. Tracked in a JSON registry
+// so `codehost list`/`stop` can see and manage these alongside oxmgr daemons.
+//
+// Tradeoff vs oxmgr: no login auto-start (that's oxmgr's per-OS service bit). It
+// does survive the launching shell and restarts the server on crash.
+
+const ROOT = join(homedir(), ".codehost");
+const REGISTRY = join(ROOT, "daemons.json");
+const LOG_DIR = join(ROOT, "logs");
+
+export interface FallbackDaemon {
+  name: string;
+  /** Supervisor process pid. */
+  pid: number;
+  cwd: string;
+  /** The foreground serve argv the supervisor (re)spawns. */
+  argv: string[];
+  log: string;
+  startedAt: number;
+}
+
+function readRegistry(): FallbackDaemon[] {
+  try {
+    return JSON.parse(readFileSync(REGISTRY, "utf8")) as FallbackDaemon[];
+  } catch {
+    return [];
+  }
+}
+
+function writeRegistry(list: FallbackDaemon[]): void {
+  mkdirSync(dirname(REGISTRY), { recursive: true });
+  writeFileSync(REGISTRY, JSON.stringify(list, null, 2));
+}
+
+/** True if a pid is currently alive (signal 0 probe). */
+export function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start (replacing any same-named instance) a detached, self-restarting daemon
+ * that runs `argv` from `cwd`, with output appended to a per-daemon log. Returns
+ * false if the supervisor couldn't be spawned.
+ */
+export function startFallbackDaemon(opts: { name: string; argv: string[]; cwd: string }): boolean {
+  stopFallbackDaemon(opts.name); // replace any previous instance with this name
+
+  mkdirSync(LOG_DIR, { recursive: true });
+  const log = join(LOG_DIR, `${opts.name}.log`);
+  const fd = openSync(log, "a");
+  const proc = spawn(
+    [process.execPath, process.argv[1], "__supervise", "--name", opts.name, "--argv", JSON.stringify(opts.argv)],
+    { cwd: opts.cwd, stdin: "ignore", stdout: fd, stderr: fd },
+  );
+  // Detach so the launching process (setup / serve -d) can exit while this keeps
+  // running as an orphan.
+  proc.unref();
+  if (!proc.pid) return false;
+
+  const list = readRegistry().filter((d) => d.name !== opts.name);
+  list.push({ name: opts.name, pid: proc.pid, cwd: opts.cwd, argv: opts.argv, log, startedAt: Date.now() });
+  writeRegistry(list);
+  return true;
+}
+
+/** Live detached daemons (dead registry entries are pruned as a side effect). */
+export function listFallbackDaemons(): FallbackDaemon[] {
+  const list = readRegistry();
+  const alive = list.filter((d) => isAlive(d.pid));
+  if (alive.length !== list.length) writeRegistry(alive);
+  return alive;
+}
+
+/** Stop and deregister a detached daemon by name. Returns false if not found. */
+export function stopFallbackDaemon(name: string): boolean {
+  const list = readRegistry();
+  const hit = list.find((d) => d.name === name);
+  if (!hit) return false;
+  try {
+    process.kill(hit.pid); // SIGTERM -> supervisor kills its child, then exits
+  } catch {
+    // already gone
+  }
+  writeRegistry(list.filter((d) => d.name !== name));
+  return true;
+}
+
+/**
+ * Supervisor body (run via the hidden `__supervise` command). Runs the serve
+ * argv, restarting it on a non-zero exit with capped exponential backoff; stops
+ * when the child exits cleanly or when this process receives SIGTERM/SIGINT
+ * (killing the child first). Output goes to the inherited log fd.
+ */
+export async function runSupervisor(name: string, argv: string[]): Promise<number> {
+  let child: Subprocess | null = null;
+  let stopping = false;
+  const onSignal = () => {
+    stopping = true;
+    try {
+      child?.kill();
+    } catch {
+      // ignore
+    }
+  };
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+
+  let attempt = 0;
+  while (!stopping) {
+    console.log(`[codehost:${name}] starting: ${argv.join(" ")}`);
+    child = spawn(argv, { cwd: process.cwd(), stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+    const code = await child.exited;
+    if (stopping) break;
+    if (code === 0) {
+      console.log(`[codehost:${name}] server exited cleanly; supervisor stopping.`);
+      break;
+    }
+    attempt++;
+    const waitMs = Math.min(30_000, 1000 * 2 ** Math.min(attempt, 5));
+    console.error(
+      `[codehost:${name}] server exited with code ${code}; restarting in ${Math.round(waitMs / 1000)}s (attempt ${attempt}).`,
+    );
+    await Bun.sleep(waitMs);
+  }
+  return 0;
+}

package/src/cli/index.ts

@@ -8,6 +8,7 @@ import { exposeCommand } from "./commands/expose";
 import { listCommand } from "./commands/list";
 import { stopCommand } from "./commands/stop";
 import { updateCommand } from "./commands/update";
+import { superviseCommand } from "./commands/supervise";
 
 yargs(hideBin(process.argv))
   .scriptName("codehost")
@@ -19,6 +20,7 @@ yargs(hideBin(process.argv))
   .command(listCommand)
   .command(stopCommand)
   .command(updateCommand)
+  .command(superviseCommand)
   .demandCommand(1, "Specify a command, e.g. `codehost serve`")
   .strict()
   .help()