codehost 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.9.0](https://github.com/snomiao/codehost/compare/v0.8.0...v0.9.0) (2026-06-08)
+
+
+### Features
+
+* Windows fallback daemon via Scheduled Task (persists + auto-starts at logon) ([cd72bb7](https://github.com/snomiao/codehost/commit/cd72bb7954d05ddf093337b627bcf6b9e9003c53))
+
 # [0.8.0](https://github.com/snomiao/codehost/compare/v0.7.1...v0.8.0) (2026-06-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "repository": {
     "type": "git",

package/src/cli/commands/supervise.ts

@@ -3,22 +3,18 @@ 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.
+// Hidden internal command: the supervisor process behind a fallback daemon (see
+// fallback-daemon.ts). Not meant to be run by hand — `serve -d` / `setup` launch
+// it (detached child on POSIX, scheduled task on Windows) when oxmgr isn't
+// available. It reads its serve argv from the registry by name.
 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,
+  builder: (y) => y.option("name", { type: "string", demandOption: true }) as any,
   handler: async (a) => {
-    const argv = JSON.parse(a.argv) as string[];
-    const code = await runSupervisor(a.name, argv);
+    const code = await runSupervisor(a.name);
     process.exit(code);
   },
 };

package/src/cli/fallback-daemon.ts

@@ -1,30 +1,38 @@
 import { spawn, type Subprocess } from "bun";
+import { spawnSync } from "node:child_process";
 import { mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { killProcessTree } from "./proc";
 
-// 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.
+// A non-oxmgr daemon manager: keeps a server running across the shell without
+// depending on oxmgr's flaky native binary. Two backends:
+//   - Windows: a Scheduled Task (`schtasks`) — built in, always runnable, and it
+//     also auto-starts the server at logon. Unref'd child processes don't
+//     survive their launcher exiting on Windows, so a task is required.
+//   - POSIX: a detached, unref'd supervisor child (reparents to init).
+// Both run the same `__supervise` loop (restart-on-failure) and read their serve
+// argv from this registry by name, so the task/launch command stays short.
 
 const ROOT = join(homedir(), ".codehost");
 const REGISTRY = join(ROOT, "daemons.json");
 const LOG_DIR = join(ROOT, "logs");
+const TASK_DIR = join(ROOT, "tasks");
+const isWindows = process.platform === "win32";
 
 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;
+  /** POSIX: supervisor process pid. */
+  pid?: number;
+  /** Windows: scheduled-task name (equals `name`). */
+  task?: string;
+  /** Pid of the serve child the supervisor last spawned (for tree-kill on stop). */
+  servePid?: number;
 }
 
 function readRegistry(): FallbackDaemon[] {
@@ -40,6 +48,18 @@ function writeRegistry(list: FallbackDaemon[]): void {
   writeFileSync(REGISTRY, JSON.stringify(list, null, 2));
 }
 
+function upsert(entry: FallbackDaemon): void {
+  writeRegistry([...readRegistry().filter((d) => d.name !== entry.name), entry]);
+}
+
+function patch(name: string, fields: Partial<FallbackDaemon>): void {
+  const list = readRegistry();
+  const hit = list.find((d) => d.name === name);
+  if (!hit) return;
+  Object.assign(hit, fields);
+  writeRegistry(list);
+}
+
 /** True if a pid is currently alive (signal 0 probe). */
 export function isAlive(pid: number): boolean {
   try {
@@ -50,67 +70,113 @@ export function isAlive(pid: number): boolean {
   }
 }
 
+function schtasks(args: string[]): number {
+  return spawnSync("schtasks", args, { stdio: "ignore" }).status ?? 1;
+}
+
+/** True if a Windows scheduled task with this name is registered. */
+function taskExists(name: string): boolean {
+  return spawnSync("schtasks", ["/query", "/tn", name], { stdio: "ignore" }).status === 0;
+}
+
 /**
- * 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.
+ * Start (replacing any same-named instance) a daemon that runs `argv` from
+ * `cwd`. Returns false if it couldn't be started. The registry entry is written
+ * first so the supervisor can read its argv by name.
  */
 export function startFallbackDaemon(opts: { name: string; argv: string[]; cwd: string }): boolean {
-  stopFallbackDaemon(opts.name); // replace any previous instance with this name
+  stopFallbackDaemon(opts.name); // replace any previous instance
 
   mkdirSync(LOG_DIR, { recursive: true });
   const log = join(LOG_DIR, `${opts.name}.log`);
+  upsert({ name: opts.name, cwd: opts.cwd, argv: opts.argv, log, startedAt: Date.now() });
+
+  return isWindows ? startWindowsTask(opts.name, log) : startUnixSupervisor(opts.name, log);
+}
+
+/** POSIX: detached, unref'd supervisor child that survives as an orphan. */
+function startUnixSupervisor(name: string, log: string): boolean {
   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.
+  const proc = spawn([process.execPath, process.argv[1], "__supervise", "--name", name], {
+    stdin: "ignore",
+    stdout: fd,
+    stderr: fd,
+  });
   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);
+  patch(name, { pid: proc.pid });
   return true;
 }
 
-/** Live detached daemons (dead registry entries are pruned as a side effect). */
+/** Windows: a Scheduled Task running the supervisor, with output redirected to
+ *  the log via a small launcher .cmd (avoids schtasks /tr quoting limits). It
+ *  auto-starts at logon and is started immediately. */
+function startWindowsTask(name: string, log: string): boolean {
+  mkdirSync(TASK_DIR, { recursive: true });
+  const cmdPath = join(TASK_DIR, `${name}.cmd`);
+  const cmd = `@echo off\r\n"${process.execPath}" "${process.argv[1]}" __supervise --name "${name}" >> "${log}" 2>&1\r\n`;
+  writeFileSync(cmdPath, cmd);
+
+  // Create the task (onlogon for a normal user; onstart when running elevated as
+  // SYSTEM, where there's no interactive logon), then run it now.
+  let created = schtasks(["/create", "/tn", name, "/tr", cmdPath, "/sc", "onlogon", "/f"]);
+  if (created !== 0) created = schtasks(["/create", "/tn", name, "/tr", cmdPath, "/sc", "onstart", "/f"]);
+  if (created !== 0) return false;
+  patch(name, { task: name });
+  return schtasks(["/run", "/tn", name]) === 0;
+}
+
+/** Live daemons. Dead POSIX supervisors are pruned; Windows entries persist as
+ *  long as their task is still registered (a Ready task is a valid auto-start). */
 export function listFallbackDaemons(): FallbackDaemon[] {
   const list = readRegistry();
-  const alive = list.filter((d) => isAlive(d.pid));
+  const alive = list.filter((d) => (d.task ? taskExists(d.task) : d.pid != null && 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. */
+/** Stop and deregister a 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
+  if (hit.task) {
+    schtasks(["/end", "/tn", hit.task]);
+    schtasks(["/delete", "/tn", hit.task, "/f"]);
+    // /end hard-terminates the task's top process; kill the serve subtree (VS
+    // Code) too so it doesn't orphan.
+    if (hit.servePid) killProcessTree(hit.servePid);
+  } else if (hit.pid != null) {
+    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.
+ * Supervisor body (run via the hidden `__supervise` command). Loads its serve
+ * argv + cwd from the registry by name, runs it, and restarts it on a non-zero
+ * exit with capped exponential backoff; stops when the child exits cleanly or on
+ * SIGTERM/SIGINT (killing the child first).
  */
-export async function runSupervisor(name: string, argv: string[]): Promise<number> {
+export async function runSupervisor(name: string): Promise<number> {
+  const entry = readRegistry().find((d) => d.name === name);
+  if (!entry) {
+    console.error(`[codehost:${name}] no registry entry; nothing to supervise.`);
+    return 1;
+  }
+  const { argv, cwd } = entry;
+
   let child: Subprocess | null = null;
   let stopping = false;
   const onSignal = () => {
     stopping = true;
     try {
-      child?.kill();
+      if (child?.pid) killProcessTree(child.pid);
     } catch {
       // ignore
     }
@@ -121,7 +187,8 @@ export async function runSupervisor(name: string, argv: string[]): Promise<numbe
   let attempt = 0;
   while (!stopping) {
     console.log(`[codehost:${name}] starting: ${argv.join(" ")}`);
-    child = spawn(argv, { cwd: process.cwd(), stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+    child = spawn(argv, { cwd, stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+    patch(name, { servePid: child.pid });
     const code = await child.exited;
     if (stopping) break;
     if (code === 0) {