codehost 0.8.0 → 0.9.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.9.1](https://github.com/snomiao/codehost/compare/v0.9.0...v0.9.1) (2026-06-08)
+
+
+### Bug Fixes
+
+* **web:** stop rendering raw room token in the input ([abf7ea5](https://github.com/snomiao/codehost/commit/abf7ea5abd96f156f178f5f5c8ddb0e31f8fdd81))
+
+# [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.1",
   "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) {

package/src/web/discovery.tsx

@@ -103,7 +103,11 @@ export function Discovery() {
     }
     return localStorage.getItem(TOKEN_KEY) ?? "";
   });
-  const [draft, setDraft] = useState(token);
+  // The token is a bearer secret — never pre-fill the input with it (it would be
+  // left in plaintext in the DOM on every load). Start blank; once a token is
+  // saved we show a masked label instead, and only reveal the input on "Change".
+  const [draft, setDraft] = useState("");
+  const [editingToken, setEditingToken] = useState(false);
   const [tokenError, setTokenError] = useState<string | null>(null);
   const [connected, setConnected] = useState(false);
   const [servers, setServers] = useState<PeerInfo[]>([]);
@@ -227,6 +231,8 @@ export function Discovery() {
     setTokenError(null);
     localStorage.setItem(TOKEN_KEY, t);
     setToken(t);
+    setDraft("");
+    setEditingToken(false);
   }
 
   async function connectTo(server: PeerInfo, folder?: string) {
@@ -428,25 +434,46 @@ export function Discovery() {
             {token ? "waiting for a live server" : "enter the room's token below"}.
           </p>
         )}
-        <form onSubmit={applyToken} style={styles.tokenForm}>
-          <label style={styles.label}>Token</label>
-          <input
-            value={draft}
-            onChange={(e) => {
-              setDraft(e.target.value);
-              if (tokenError) setTokenError(null);
-            }}
-            placeholder="your room token"
-            style={styles.input}
-          />
-          <button type="submit" style={styles.button}>
-            {token === draft.trim() ? "Reconnect" : "Connect"}
-          </button>
-        </form>
-        {tokenError ? (
-          <p style={styles.tokenError}>{tokenError}</p>
+        {token && !editingToken ? (
+          <div style={styles.tokenForm}>
+            <label style={styles.label}>Token</label>
+            <span style={styles.tokenSaved}>saved · {roomLabel}</span>
+            <button
+              type="button"
+              style={styles.shareBtn}
+              onClick={() => {
+                setDraft("");
+                setTokenError(null);
+                setEditingToken(true);
+              }}
+            >
+              Change
+            </button>
+          </div>
         ) : (
-          <p style={styles.tokenHint}>Token requires {TOKEN_REQUIREMENTS}.</p>
+          <>
+            <form onSubmit={applyToken} style={styles.tokenForm}>
+              <label style={styles.label}>Token</label>
+              <input
+                value={draft}
+                onChange={(e) => {
+                  setDraft(e.target.value);
+                  if (tokenError) setTokenError(null);
+                }}
+                placeholder="your room token"
+                style={styles.input}
+                autoFocus={editingToken}
+              />
+              <button type="submit" style={styles.button}>
+                Connect
+              </button>
+            </form>
+            {tokenError ? (
+              <p style={styles.tokenError}>{tokenError}</p>
+            ) : (
+              <p style={styles.tokenHint}>Token requires {TOKEN_REQUIREMENTS}.</p>
+            )}
+          </>
         )}
 
         <div style={styles.listHead}>
@@ -544,6 +571,7 @@ const styles: Record<string, React.CSSProperties> = {
   tokenHint: { margin: "0 0 20px", fontSize: 12, color: "#888" },
   tokenError: { margin: "0 0 20px", fontSize: 12, color: "#f48771" },
   label: { fontSize: 12, color: "#888" },
+  tokenSaved: { flex: 1, fontFamily: "monospace", fontSize: 13, color: "#4ec9b0" },
   input: { flex: 1, background: "#252525", border: "1px solid #3d3d3d", color: "#eee", padding: "8px 10px", borderRadius: 6, fontSize: 13, outline: "none" },
   button: { background: "#0e639c", border: "none", color: "#fff", padding: "8px 16px", borderRadius: 6, cursor: "pointer", fontSize: 13 },
   listHead: { display: "flex", alignItems: "baseline", gap: 10, margin: "0 0 12px" },