@task0/cli 0.1.0 → 0.2.1

package/README.md

@@ -62,6 +62,55 @@ task0 task triage <id>   # decompose an IDEA into ISSUE files
 task0 run <id>           # drive the full triage → plan → refine → exec loop
 ```
 
+## Run as a service (autostart on login / boot)
+
+`task0 daemon register` installs an OS-level autostart service in addition to
+recording the daemon identity. After registering you can sign out, reboot, and
+the daemon reconnects on its own.
+
+```sh
+# user-level (default) — starts at user login, no sudo needed
+task0 daemon register --server https://central.example.com:4318
+
+# system-level — starts at boot, runs without an active login
+sudo -E task0 daemon register --system --server https://central.example.com:4318
+
+# pause / resume without forgetting the identity
+task0 daemon stop
+task0 daemon start
+
+# disable everything: stop the service, remove the unit, clear the identity
+task0 daemon logout
+```
+
+Per platform:
+
+| Platform | Scope    | File written |
+|----------|----------|--------------|
+| macOS    | user     | `~/Library/LaunchAgents/cc.cy0.task0.plist` (launchd) |
+| macOS    | system   | `/Library/LaunchDaemons/cc.cy0.task0.plist` (launchd, needs sudo) |
+| Linux    | user     | `~/.config/systemd/user/cc.cy0.task0.service` (systemd) |
+| Linux    | system   | `/etc/systemd/system/cc.cy0.task0.service` (systemd, needs sudo) |
+
+Logs land in `~/.task0/logs/daemon.{out,err}.log`. To watch them live:
+
+```sh
+tail -f ~/.task0/logs/daemon.out.log
+```
+
+Linux user-scope note: systemd kills the service when you log out. To keep it
+running across logouts, enable lingering once: `sudo loginctl enable-linger $USER`.
+
+Useful flags on `register`:
+
+- `--no-install` — register identity only; do not write a service unit
+- `--no-start` — write the unit but do not start it immediately
+- `--force` — re-register over an existing identity
+
+For debugging or supervised setups you can also invoke the WebSocket loop
+directly in the foreground with `task0 daemon run` (this is the same command
+that the service unit invokes internally).
+
 ## Environment variables
 
 | Variable                      | Purpose                                                              |

package/dist/main.js

@@ -901,6 +901,9 @@ var init_task_state2 = __esm({
 });
 
 // src/main.ts
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path24 from "path";
 import { Command as Command22 } from "commander";
 
 // src/commands/source.ts
@@ -1141,11 +1144,11 @@ async function request(method, pathname, body) {
   return parsed;
 }
 var api = {
-  get: (path21) => request("GET", path21),
-  post: (path21, body) => request("POST", path21, body ?? {}),
-  put: (path21, body) => request("PUT", path21, body ?? {}),
-  patch: (path21, body) => request("PATCH", path21, body ?? {}),
-  del: (path21) => request("DELETE", path21)
+  get: (path25) => request("GET", path25),
+  post: (path25, body) => request("POST", path25, body ?? {}),
+  put: (path25, body) => request("PUT", path25, body ?? {}),
+  patch: (path25, body) => request("PATCH", path25, body ?? {}),
+  del: (path25) => request("DELETE", path25)
 };
 
 // src/commands/task/triage.ts
@@ -3809,7 +3812,7 @@ async function streamOutput(ref, runtimeId) {
 }
 
 // src/commands/daemon.ts
-import os5 from "os";
+import os6 from "os";
 import { Command as Command20 } from "commander";
 import chalk20 from "chalk";
 import WebSocket from "ws";
@@ -3887,6 +3890,308 @@ var rpcHandlers = {
   }
 };
 
+// src/core/daemon-service/launchd.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import fs23 from "fs";
+import path22 from "path";
+
+// src/core/daemon-service/binary.ts
+import fs22 from "fs";
+import { fileURLToPath } from "url";
+function resolveTask0Invocation() {
+  const node = process.execPath;
+  const argv1 = process.argv[1] ?? fileURLToPath(import.meta.url);
+  const main2 = fs22.realpathSync(argv1);
+  if (!isInstalledBuild(main2) && process.env.TASK0_ALLOW_DEV_SERVICE !== "1") {
+    throw new Error(
+      `Refusing to install autostart service pointing at ${main2}.
+That looks like a development source, not an installed @task0/cli build.
+Install the CLI globally (\`npm i -g @task0/cli\`) and retry, or set
+TASK0_ALLOW_DEV_SERVICE=1 to override.`
+    );
+  }
+  return { node, main: main2, args: ["daemon", "run"] };
+}
+function isInstalledBuild(p) {
+  return /[/\\]dist[/\\]main\.js$/.test(p);
+}
+
+// src/core/daemon-service/paths.ts
+import os5 from "os";
+import path21 from "path";
+
+// src/core/daemon-service/types.ts
+var SERVICE_LABEL = "cc.cy0.task0";
+
+// src/core/daemon-service/paths.ts
+function unitPath(scope) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return scope === "user" ? path21.join(os5.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) : path21.join("/", "Library", "LaunchDaemons", `${SERVICE_LABEL}.plist`);
+  }
+  if (platform === "linux") {
+    return scope === "user" ? path21.join(os5.homedir(), ".config", "systemd", "user", `${SERVICE_LABEL}.service`) : path21.join("/", "etc", "systemd", "system", `${SERVICE_LABEL}.service`);
+  }
+  throw new Error(`Unsupported platform for service install: ${platform}`);
+}
+function logDir() {
+  return path21.join(os5.homedir(), ".task0", "logs");
+}
+function logPaths() {
+  const dir = logDir();
+  return {
+    out: path21.join(dir, "daemon.out.log"),
+    err: path21.join(dir, "daemon.err.log")
+  };
+}
+
+// src/core/daemon-service/launchd.ts
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderPlist(opts) {
+  const programArgs = [opts.node, opts.main, ...opts.args].map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(opts.out)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(opts.err)}</string>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(opts.home)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+function domainTarget(scope) {
+  if (scope === "system") return "system";
+  const uid = process.getuid?.() ?? 0;
+  return `gui/${uid}`;
+}
+function serviceTarget(scope) {
+  return `${domainTarget(scope)}/${SERVICE_LABEL}`;
+}
+function run2(cmd, args) {
+  const res = spawnSync5(cmd, args, { encoding: "utf-8" });
+  return { code: res.status ?? -1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
+}
+function createLaunchdManager(scope) {
+  const file = unitPath(scope);
+  const logs = logPaths();
+  async function install() {
+    const inv = resolveTask0Invocation();
+    fs23.mkdirSync(logDir(), { recursive: true });
+    fs23.mkdirSync(path22.dirname(file), { recursive: true });
+    const body = renderPlist({
+      node: inv.node,
+      main: inv.main,
+      args: inv.args,
+      home: process.env.HOME ?? "/",
+      out: logs.out,
+      err: logs.err
+    });
+    fs23.writeFileSync(file, body, { mode: 420 });
+    const bootstrap = run2("launchctl", ["bootstrap", domainTarget(scope), file]);
+    if (bootstrap.code !== 0) {
+      const already = /already loaded|service already bootstrapped/i.test(bootstrap.stderr);
+      if (already) {
+        run2("launchctl", ["bootout", serviceTarget(scope)]);
+        const retry = run2("launchctl", ["bootstrap", domainTarget(scope), file]);
+        if (retry.code !== 0) {
+          const legacy = run2("launchctl", ["load", "-w", file]);
+          if (legacy.code !== 0) {
+            throw new Error(
+              `launchctl bootstrap/load failed: ${retry.stderr || legacy.stderr || bootstrap.stderr}`
+            );
+          }
+        }
+      } else {
+        const legacy = run2("launchctl", ["load", "-w", file]);
+        if (legacy.code !== 0) {
+          throw new Error(`launchctl bootstrap/load failed: ${bootstrap.stderr || legacy.stderr}`);
+        }
+      }
+    }
+    return { unitPath: file };
+  }
+  async function uninstall() {
+    run2("launchctl", ["bootout", serviceTarget(scope)]);
+    if (fs23.existsSync(file)) {
+      run2("launchctl", ["unload", file]);
+      fs23.unlinkSync(file);
+    }
+  }
+  async function start() {
+    const res = run2("launchctl", ["kickstart", "-k", serviceTarget(scope)]);
+    if (res.code !== 0) {
+      const load = run2("launchctl", ["load", "-w", file]);
+      if (load.code !== 0) {
+        throw new Error(`launchctl start failed: ${res.stderr || load.stderr}`);
+      }
+    }
+  }
+  async function stop() {
+    const res = run2("launchctl", ["kill", "SIGTERM", serviceTarget(scope)]);
+    if (res.code !== 0) {
+      run2("launchctl", ["unload", file]);
+    }
+  }
+  async function status() {
+    if (!fs23.existsSync(file)) return "absent";
+    const printed = run2("launchctl", ["print", serviceTarget(scope)]);
+    if (printed.code !== 0) return "installed";
+    const out = printed.stdout;
+    if (/\bstate\s*=\s*running/.test(out)) return "running";
+    if (/\bstate\s*=\s*spawning/.test(out)) return "installed";
+    if (/last exit code\s*=\s*[1-9]/i.test(out)) return "errored";
+    return "stopped";
+  }
+  return {
+    scope,
+    install,
+    uninstall,
+    start,
+    stop,
+    status,
+    unitPath: () => file,
+    logPaths: () => logs
+  };
+}
+
+// src/core/daemon-service/systemd.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import fs24 from "fs";
+import path23 from "path";
+function shellEscape(s) {
+  if (!/[\s"\\$]/.test(s)) return s;
+  return `"${s.replace(/[\\"]/g, (m) => `\\${m}`)}"`;
+}
+function renderUnit(opts) {
+  const execStart = [opts.node, opts.main, ...opts.args].map(shellEscape).join(" ");
+  const wantedBy = opts.scope === "user" ? "default.target" : "multi-user.target";
+  return `[Unit]
+Description=task0 daemon \u2014 central-server bridge
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+Restart=on-failure
+RestartSec=5s
+StandardOutput=append:${opts.out}
+StandardError=append:${opts.err}
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=${wantedBy}
+`;
+}
+function scopeFlag(scope) {
+  return scope === "user" ? ["--user"] : [];
+}
+function run3(cmd, args) {
+  const res = spawnSync6(cmd, args, { encoding: "utf-8" });
+  return { code: res.status ?? -1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
+}
+function createSystemdManager(scope) {
+  const file = unitPath(scope);
+  const logs = logPaths();
+  const unitName = `${SERVICE_LABEL}.service`;
+  async function install() {
+    const inv = resolveTask0Invocation();
+    fs24.mkdirSync(logDir(), { recursive: true });
+    fs24.mkdirSync(path23.dirname(file), { recursive: true });
+    const body = renderUnit({
+      node: inv.node,
+      main: inv.main,
+      args: inv.args,
+      out: logs.out,
+      err: logs.err,
+      scope
+    });
+    fs24.writeFileSync(file, body, { mode: 420 });
+    const reload = run3("systemctl", [...scopeFlag(scope), "daemon-reload"]);
+    if (reload.code !== 0) {
+      throw new Error(`systemctl daemon-reload failed: ${reload.stderr}`);
+    }
+    return { unitPath: file };
+  }
+  async function uninstall() {
+    run3("systemctl", [...scopeFlag(scope), "disable", "--now", unitName]);
+    if (fs24.existsSync(file)) {
+      fs24.unlinkSync(file);
+    }
+    run3("systemctl", [...scopeFlag(scope), "daemon-reload"]);
+  }
+  async function start() {
+    const res = run3("systemctl", [...scopeFlag(scope), "enable", "--now", unitName]);
+    if (res.code !== 0) {
+      throw new Error(`systemctl enable --now failed: ${res.stderr}`);
+    }
+  }
+  async function stop() {
+    const res = run3("systemctl", [...scopeFlag(scope), "stop", unitName]);
+    if (res.code !== 0) {
+      throw new Error(`systemctl stop failed: ${res.stderr}`);
+    }
+  }
+  async function status() {
+    if (!fs24.existsSync(file)) return "absent";
+    const res = run3("systemctl", [...scopeFlag(scope), "is-active", unitName]);
+    const out = res.stdout.trim();
+    if (out === "active") return "running";
+    if (out === "inactive") return "stopped";
+    if (out === "failed") return "errored";
+    if (out === "activating" || out === "deactivating") return "installed";
+    return "installed";
+  }
+  return {
+    scope,
+    install,
+    uninstall,
+    start,
+    stop,
+    status,
+    unitPath: () => file,
+    logPaths: () => logs
+  };
+}
+
+// src/core/daemon-service/index.ts
+function isPlatformSupported() {
+  return process.platform === "darwin" || process.platform === "linux";
+}
+function getServiceManager(scope) {
+  if (process.platform === "darwin") return createLaunchdManager(scope);
+  if (process.platform === "linux") return createSystemdManager(scope);
+  throw new Error(
+    `Autostart service installation is not supported on ${process.platform}. Run \`task0 daemon run\` in a process supervisor of your choice.`
+  );
+}
+
 // src/commands/daemon.ts
 var DAEMON_VERSION = "0.1.0";
 async function dispatchRpc(ws, id, method, params) {
@@ -3936,15 +4241,31 @@ async function jsonGet(url) {
   }
   return res.json();
 }
+function requireRootIfSystem(scope, rerunHint) {
+  if (scope !== "system") return;
+  const uid = process.getuid?.();
+  if (uid === 0) return;
+  console.error(chalk20.red("--system requires root."));
+  console.error("Re-run with sudo, preserving env:");
+  console.error(chalk20.cyan(`  sudo -E ${rerunHint}`));
+  process.exit(1);
+}
+function rerunArgv() {
+  return ["task0", ...process.argv.slice(2)].join(" ");
+}
 var daemonCmd = new Command20("daemon").description("Manage this host as a task0 daemon registered with a central server");
-daemonCmd.command("register").description("Register this host with a central server and save the identity locally").requiredOption("-s, --server <url>", "Central server URL (e.g. https://central.example.com:4318)").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("--force", "Overwrite existing identity if present").action(async (opts) => {
+daemonCmd.command("register").description("Register this host with a central server, install the autostart service, and start it").requiredOption("-s, --server <url>", "Central server URL (e.g. https://central.example.com:4318)").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("--force", "Overwrite existing identity if present").option("--system", "Install at the system layer (LaunchDaemons / /etc/systemd/system, requires sudo)").option("--no-install", "Skip installing the autostart service unit").option("--no-start", "Install the service unit but do not start it now").action(async (opts) => {
+  const scope = opts.system ? "system" : "user";
+  if (opts.install) {
+    requireRootIfSystem(scope, rerunArgv());
+  }
   const existing = readDaemonIdentity();
   if (existing && !opts.force) {
     fail6(`Already registered as ${existing.daemon_id}. Pass --force to re-register.`);
   }
   const base = opts.server.replace(/\/$/, "");
   const body = {
-    hostname: os5.hostname(),
+    hostname: os6.hostname(),
     platform: process.platform,
     name: opts.name
   };
@@ -3974,8 +4295,67 @@ daemonCmd.command("register").description("Register this host with a central ser
   writeDaemonIdentity(identity);
   console.log(chalk20.green(`Registered as ${data.daemon.object_id} (${data.daemon.name})`));
   console.log(`Identity saved to ${daemonConfigPath()}`);
+  if (!opts.install) {
+    console.log(chalk20.dim("Skipping service install (--no-install)."));
+    console.log(chalk20.dim(`Run \`task0 daemon run\` to start the WebSocket loop in foreground.`));
+    return;
+  }
+  if (!isPlatformSupported()) {
+    console.log(
+      chalk20.yellow(
+        `Autostart service is not supported on ${process.platform}. Run \`task0 daemon run\` under a supervisor of your choice.`
+      )
+    );
+    return;
+  }
+  const svc = getServiceManager(scope);
+  try {
+    const { unitPath: unitPath2 } = await svc.install({ identity });
+    const logs = svc.logPaths();
+    console.log(chalk20.green(`Installed service unit at ${unitPath2}`));
+    console.log(chalk20.dim(`Logs: ${logs.out}`));
+    console.log(chalk20.dim(`      ${logs.err}`));
+    if (opts.start) {
+      await svc.start();
+      console.log(chalk20.green("Service started."));
+    } else {
+      console.log(chalk20.dim("Skipping start (--no-start). Run `task0 daemon start` when ready."));
+    }
+  } catch (error2) {
+    console.error(chalk20.red(`Service install failed: ${error2 instanceof Error ? error2.message : String(error2)}`));
+    console.error(chalk20.dim("Identity is saved; rerun `task0 daemon register --force` once the issue is resolved."));
+    process.exit(1);
+  }
+});
+daemonCmd.command("start").description("Start the installed autostart service via launchctl / systemctl").option("--system", "Target the system-layer service").action(async (opts) => {
+  const scope = opts.system ? "system" : "user";
+  requireRootIfSystem(scope, rerunArgv());
+  if (!isPlatformSupported()) {
+    fail6(`Service control is not supported on ${process.platform}.`);
+  }
+  const svc = getServiceManager(scope);
+  try {
+    await svc.start();
+    console.log(chalk20.green("Service started."));
+  } catch (error2) {
+    fail6(error2 instanceof Error ? error2.message : String(error2));
+  }
+});
+daemonCmd.command("stop").description("Stop the autostart service via launchctl / systemctl").option("--system", "Target the system-layer service").action(async (opts) => {
+  const scope = opts.system ? "system" : "user";
+  requireRootIfSystem(scope, rerunArgv());
+  if (!isPlatformSupported()) {
+    fail6(`Service control is not supported on ${process.platform}.`);
+  }
+  const svc = getServiceManager(scope);
+  try {
+    await svc.stop();
+    console.log(chalk20.green("Service stopped."));
+  } catch (error2) {
+    fail6(error2 instanceof Error ? error2.message : String(error2));
+  }
 });
-daemonCmd.command("start").description("Start the local daemon and connect to the registered server (long-running)").action(async () => {
+daemonCmd.command("run").description("Run the daemon WebSocket loop in foreground (invoked by the service unit; useful for debugging)").action(async () => {
   const identity = loadRequiredIdentity();
   const wsUrl = identity.server_url.replace(/^http/, "ws").replace(/\/$/, "") + "/ws/daemon";
   console.log(chalk20.green(`Starting daemon ${identity.daemon_id} \u2192 ${wsUrl}`));
@@ -4066,17 +4446,42 @@ daemonCmd.command("list").description("List daemons registered on the configured
     );
   }
 });
-daemonCmd.command("show [daemonId]").description("Show local daemon identity (no arg) or remote daemon by id").action(async (daemonId) => {
+daemonCmd.command("show [daemonId]").description("Show local daemon identity (no arg) or remote daemon by id").option("--system", "Inspect the system-layer service status (default: user)").action(async (daemonId, opts) => {
   if (!daemonId) {
     const identity = loadRequiredIdentity();
     console.log(JSON.stringify({ ...identity, token: "***" }, null, 2));
+    if (isPlatformSupported()) {
+      const scope = opts.system ? "system" : "user";
+      try {
+        const svc = getServiceManager(scope);
+        const state2 = await svc.status();
+        console.log(chalk20.dim(`service (${scope}): ${state2}  \u2192  ${svc.unitPath()}`));
+      } catch (error2) {
+        console.log(chalk20.dim(`service status unavailable: ${error2 instanceof Error ? error2.message : String(error2)}`));
+      }
+    }
     return;
   }
   const base = serverBase(readDaemonIdentity());
   const data = await jsonGet(`${base}/api/daemons/${encodeURIComponent(daemonId)}`);
   console.log(JSON.stringify(data.daemon, null, 2));
 });
-daemonCmd.command("logout").description("Forget the locally stored daemon identity").action(() => {
+daemonCmd.command("logout").description("Stop and uninstall the autostart service, then forget the locally stored daemon identity").option("--system", "Target the system-layer service").option("--keep-service", "Leave the installed service unit in place; only clear the identity file").action(async (opts) => {
+  const scope = opts.system ? "system" : "user";
+  if (!opts.keepService) {
+    requireRootIfSystem(scope, rerunArgv());
+    if (isPlatformSupported()) {
+      const svc = getServiceManager(scope);
+      try {
+        await svc.uninstall();
+        console.log(chalk20.dim(`Service unit removed (${scope}).`));
+      } catch (error2) {
+        console.error(
+          chalk20.yellow(`Service uninstall warning: ${error2 instanceof Error ? error2.message : String(error2)}`)
+        );
+      }
+    }
+  }
   if (clearDaemonIdentity()) {
     console.log(chalk20.green("Daemon identity cleared."));
   } else {
@@ -4345,7 +4750,16 @@ function captureTopLevel(err, options) {
 }
 
 // src/main.ts
-var TASK0_VERSION = "0.1.0";
+var TASK0_VERSION = readVersion();
+function readVersion() {
+  try {
+    const here = path24.dirname(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(readFileSync(path24.resolve(here, "..", "package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 var program = new Command22().name("task0").description("Task-centric control layer for agent workflow").version(TASK0_VERSION);
 program.addCommand(source);
 program.addCommand(project);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task0/cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "task0 — task-centric agent workflow CLI",
   "homepage": "https://github.com/cy0-labs/task0#readme",
   "repository": {