codehost 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.7.1](https://github.com/snomiao/codehost/compare/v0.7.0...v0.7.1) (2026-06-08)
+
+
+### Bug Fixes
+
+* ch list shows only codehost daemons, not all oxmgr processes ([e9cf4fc](https://github.com/snomiao/codehost/commit/e9cf4fca40b653c430c26eb29ba47ef9a154f089))
+* kill the VS Code serve-web process tree on stop (no orphans) ([d6337f6](https://github.com/snomiao/codehost/commit/d6337f6d45bf41fb57f2d0cd28c60a70f55f62d0))
+
 # [0.7.0](https://github.com/snomiao/codehost/compare/v0.6.0...v0.7.0) (2026-06-08)
 
 

package/package.json

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

package/src/cli/commands/list.ts

@@ -18,7 +18,11 @@ export const listCommand: CommandModule = {
     // 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());
+      const shown = await listDaemons();
+      // listDaemons returns the count of codehost daemons (>=0) or -1 if oxmgr
+      // is unusable; only the latter is an error exit. It prints its own
+      // "No codehost daemons running." message when the count is 0.
+      process.exit(shown < 0 ? 1 : 0);
     }
     if (!detached.length) console.log("No codehost daemons running.");
     process.exit(0);

package/src/cli/oxmgr.ts

@@ -117,10 +117,43 @@ function enableStartup(): void {
   }
 }
 
-/** `codehost list` -> oxmgr's process table. */
+/**
+ * `codehost list` -> oxmgr's process table, filtered to codehost-owned daemons.
+ *
+ * oxmgr is a shared process manager (other tools register their own services
+ * with it), so a raw `oxmgr list` leaks unrelated processes. oxmgr has no JSON
+ * or name-filter flag, so we capture its ASCII table and drop data rows whose
+ * NAME column isn't one of ours (the `codehost-` prefix from `daemonName`).
+ * Returns the number of codehost daemons shown (-1 if oxmgr is unusable).
+ */
 export async function listDaemons(): Promise<number> {
-  if (!(await ensureOxmgr())) return 1;
-  return ox(["list"], { stdio: "inherit" });
+  if (!(await ensureOxmgr())) return -1;
+  const entry = oxmgrEntry();
+  if (!entry) return -1;
+  const r = spawnSync(process.execPath, [entry, "list"], { encoding: "utf8" });
+  if (r.status !== 0) {
+    if (r.stderr) process.stderr.write(r.stderr);
+    return -1;
+  }
+  const lines = (r.stdout ?? "").split("\n");
+  let shown = 0;
+  const kept = lines.filter((line) => {
+    // Border lines (+----+) and blank lines pass through unchanged.
+    if (!line.startsWith("|")) return true;
+    const name = line.split("|")[2]?.trim() ?? "";
+    if (name === "NAME") return true; // header row
+    if (name.startsWith("codehost-")) {
+      shown++;
+      return true;
+    }
+    return false;
+  });
+  if (shown === 0) {
+    console.log("No codehost daemons running.");
+    return 0;
+  }
+  process.stdout.write(kept.join("\n"));
+  return shown;
 }
 
 /** `codehost stop <name>` -> stop + delete the oxmgr process. */

package/src/cli/proc.ts

@@ -0,0 +1,57 @@
+import { spawnSync } from "node:child_process";
+
+/**
+ * Kill a process and all of its descendants. VS Code's `serve-web` launcher
+ * double-forks (code -> code-tunnel -> code-server -> node server-main.js), so
+ * killing only the spawned launcher leaves the real server running as orphans.
+ * Killing the whole tree avoids that leak. Best-effort and synchronous so it can
+ * run inside a shutdown handler right before the process exits.
+ */
+export function killProcessTree(pid: number, signal: NodeJS.Signals = "SIGTERM"): void {
+  if (!pid || pid <= 1) return;
+  if (process.platform === "win32") {
+    // /T kills the process and its child tree; /F forces it.
+    spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+    return;
+  }
+  // POSIX: signal descendants (leaves first) then the root itself.
+  for (const p of [...descendants(pid), pid]) {
+    try {
+      process.kill(p, signal);
+    } catch {
+      // already gone
+    }
+  }
+}
+
+/** PIDs descended from `root`, deepest first (so they can be signalled before
+ *  their parents). Uses `ps`; returns [] if it's unavailable. */
+function descendants(root: number): number[] {
+  let out = "";
+  try {
+    out = spawnSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8" }).stdout ?? "";
+  } catch {
+    return [];
+  }
+  const childrenOf = new Map<number, number[]>();
+  for (const line of out.split("\n")) {
+    const cols = line.trim().split(/\s+/);
+    if (cols.length < 2) continue;
+    const pid = Number(cols[0]);
+    const ppid = Number(cols[1]);
+    if (!Number.isFinite(pid) || !Number.isFinite(ppid)) continue;
+    const arr = childrenOf.get(ppid);
+    if (arr) arr.push(pid);
+    else childrenOf.set(ppid, [pid]);
+  }
+  const result: number[] = [];
+  const stack = [root];
+  while (stack.length) {
+    const p = stack.pop()!;
+    for (const c of childrenOf.get(p) ?? []) {
+      result.push(c);
+      stack.push(c);
+    }
+  }
+  return result.reverse();
+}

package/src/cli/vscode.ts

@@ -1,5 +1,6 @@
 import { spawn, type Subprocess } from "bun";
 import { resolveCodeBinary } from "./vscode-install";
+import { killProcessTree } from "./proc";
 
 // How long to wait for `code serve-web` to answer. The default is generous
 // because the FIRST run downloads the server component, which can take minutes
@@ -61,7 +62,10 @@ export async function launchVscode(opts: LaunchOptions): Promise<VscodeServer> {
 
   const stop = () => {
     try {
-      proc.kill();
+      // serve-web double-forks; kill the whole tree so the real VS Code server
+      // doesn't linger as an orphan after the daemon stops.
+      if (proc.pid) killProcessTree(proc.pid);
+      else proc.kill();
     } catch {
       // ignore
     }