@task0/cli 0.10.0 → 0.12.0

package/dist/main.js

@@ -1909,11 +1909,11 @@ async function request(method, pathname, body) {
   }
 }
 var api = {
-  get: (path32) => request("GET", path32),
-  post: (path32, body) => request("POST", path32, body ?? {}),
-  put: (path32, body) => request("PUT", path32, body ?? {}),
-  patch: (path32, body) => request("PATCH", path32, body ?? {}),
-  del: (path32) => request("DELETE", path32)
+  get: (path33) => request("GET", path33),
+  post: (path33, body) => request("POST", path33, body ?? {}),
+  put: (path33, body) => request("PUT", path33, body ?? {}),
+  patch: (path33, body) => request("PATCH", path33, body ?? {}),
+  del: (path33) => request("DELETE", path33)
 };
 
 // src/commands/task/triage.ts
@@ -4763,6 +4763,9 @@ function emitAgentRunStatus(runId, status, opts = {}) {
     phase: opts.phase ?? null,
     exit_code: opts.exitCode ?? null,
     error: opts.error ?? null,
+    agent_session_id: opts.agentSessionId ?? null,
+    agent_project: opts.agentProject ?? null,
+    metadata: opts.metadata ?? null,
     ts: (/* @__PURE__ */ new Date()).toISOString()
   });
   if (status === "completed" || status === "failed" || status === "killed") {
@@ -4872,6 +4875,28 @@ function checkTmuxAvailable() {
     return { ok: false, reason: `tmux not available: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
+function injectNodeBin(scriptContent) {
+  const nodeBin = process.execPath;
+  const nodeDir = path25.dirname(nodeBin);
+  const home = process.env.HOME ?? "";
+  const extraPath = [
+    nodeDir,
+    home ? `${home}/.local/share/mise/shims` : "",
+    home ? `${home}/.local/bin` : "",
+    home ? `${home}/bin` : "",
+    home ? `${home}/.cargo/bin` : ""
+  ].filter(Boolean).join(":");
+  const injected = [
+    `NODE_BIN=${JSON.stringify(nodeBin)}`,
+    `export PATH=${JSON.stringify(extraPath)}:"$PATH"`,
+    ""
+  ].join("\n");
+  const shebangMatch = scriptContent.match(/^(#![^\n]*\n)/);
+  if (shebangMatch) {
+    return shebangMatch[1] + injected + scriptContent.slice(shebangMatch[1].length);
+  }
+  return injected + scriptContent;
+}
 function isSessionAlive2(sessionName) {
   try {
     execFileSync(getTmuxBin(), ["has-session", "-t", sessionName], {
@@ -4911,7 +4936,17 @@ function deriveStatus(parsed) {
   else if (raw === "error" || raw === "failed") status = "failed";
   const phase = typeof parsed.phase === "string" ? parsed.phase : null;
   const error2 = typeof parsed.error === "string" && parsed.error ? parsed.error : null;
-  return { status, phase, error: error2 };
+  const agentSessionId = typeof parsed.agentSessionId === "string" && parsed.agentSessionId ? parsed.agentSessionId : null;
+  const agentProject = typeof parsed.agentProject === "string" && parsed.agentProject ? parsed.agentProject : null;
+  let metadata = null;
+  if (parsed.metadata && typeof parsed.metadata === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(parsed.metadata)) {
+      if (typeof k === "string" && typeof v === "string") out[k] = v;
+    }
+    if (Object.keys(out).length > 0) metadata = out;
+  }
+  return { status, phase, error: error2, agentSessionId, agentProject, metadata };
 }
 function launchAgentRun(params) {
   const tmuxCheck = checkTmuxAvailable();
@@ -4926,9 +4961,11 @@ function launchAgentRun(params) {
   }
   const runDir = ensureAgentRunDir(params.runId);
   const scriptPath = path25.join(runDir, "script.sh");
-  fs27.writeFileSync(scriptPath, params.scriptContent, { mode: 493 });
+  const scriptWithNode = injectNodeBin(params.scriptContent);
+  fs27.writeFileSync(scriptPath, scriptWithNode, { mode: 493 });
   if (params.promptContent !== void 0) {
-    fs27.writeFileSync(path25.join(runDir, "prompt.txt"), params.promptContent, "utf-8");
+    const expanded = params.promptContent.replace(/__TASK0_AGENT_RUN_DIR__/g, runDir);
+    fs27.writeFileSync(path25.join(runDir, "prompt.txt"), expanded, "utf-8");
   }
   for (const [name, content] of Object.entries(params.auxFiles ?? {})) {
     if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
@@ -4970,7 +5007,20 @@ function launchAgentRun(params) {
       return;
     }
     if (!isSessionAlive2(cur.sessionName)) {
-      finishRun(params.runId, "killed", { error: "tmux session disappeared" });
+      const final = readStatusFile(params.runId);
+      const derived = final ? deriveStatus(final.parsed) : null;
+      if (derived && (derived.status === "completed" || derived.status === "failed")) {
+        emitAgentRunStatus(params.runId, derived.status, {
+          phase: derived.phase,
+          error: derived.error,
+          agentSessionId: derived.agentSessionId,
+          agentProject: derived.agentProject,
+          metadata: derived.metadata
+        });
+        finishRun(params.runId, derived.status, { phase: derived.phase, error: derived.error });
+      } else {
+        finishRun(params.runId, "killed", { error: "tmux session disappeared" });
+      }
       clearInterval(sessionProbe);
     }
   }, SESSION_PROBE_MS);
@@ -4983,10 +5033,16 @@ function pollOne(runId) {
   if (!current) return;
   if (current.raw === entry.lastStatusJson) return;
   entry.lastStatusJson = current.raw;
-  const { status, phase, error: error2 } = deriveStatus(current.parsed);
-  emitAgentRunStatus(runId, status, { phase, error: error2 });
-  if (status === "completed" || status === "failed") {
-    finishRun(runId, status, { phase, error: error2 });
+  const derived = deriveStatus(current.parsed);
+  emitAgentRunStatus(runId, derived.status, {
+    phase: derived.phase,
+    error: derived.error,
+    agentSessionId: derived.agentSessionId,
+    agentProject: derived.agentProject,
+    metadata: derived.metadata
+  });
+  if (derived.status === "completed" || derived.status === "failed") {
+    finishRun(runId, derived.status, { phase: derived.phase, error: derived.error });
   }
 }
 function finishRun(runId, status, opts = {}) {
@@ -6093,6 +6149,55 @@ function run2(cmd, args) {
   const res = spawnSync6(cmd, args, { encoding: "utf-8" });
   return { code: res.status ?? -1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
 }
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function launchdServicePid(scope) {
+  const res = run2("launchctl", ["print", serviceTarget(scope)]);
+  if (res.code !== 0) return null;
+  const m = res.stdout.match(/\bpid\s*=\s*(\d+)/);
+  if (!m) return null;
+  const pid = parseInt(m[1], 10);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function findOrphanDaemonPids(mainPath, excludePid) {
+  const res = run2("ps", ["-Ewwo", "pid=,command="]);
+  if (res.code !== 0) return [];
+  const expectedHome = process.env.TASK0_HOME ?? "";
+  const pids = [];
+  for (const line of res.stdout.split("\n")) {
+    const m = line.match(/^\s*(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const pid = parseInt(m[1], 10);
+    if (!Number.isFinite(pid) || pid <= 0) continue;
+    if (excludePid !== null && pid === excludePid) continue;
+    if (pid === process.pid) continue;
+    const cmd = m[2];
+    if (!cmd.includes(mainPath)) continue;
+    if (!/\bdaemon\s+run\b/.test(cmd)) continue;
+    const homeMatch = cmd.match(/\bTASK0_HOME=([^\s]*)/);
+    const actualHome = homeMatch ? homeMatch[1] : "";
+    if (actualHome !== expectedHome) continue;
+    pids.push(pid);
+  }
+  return pids;
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!pidAlive(pid)) return true;
+    await sleep2(100);
+  }
+  return false;
+}
 function createLaunchdManager(scope) {
   const file = unitPath(scope);
   const logs = logPaths();
@@ -6141,19 +6246,65 @@ function createLaunchdManager(scope) {
     }
   }
   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}`);
+    if (!fs30.existsSync(file)) {
+      throw new Error(
+        `service unit ${file} is missing \u2014 run \`task0 daemon register\` first to install it`
+      );
+    }
+    const kick = run2("launchctl", ["kickstart", "-k", serviceTarget(scope)]);
+    if (kick.code !== 0) {
+      const bootstrap = run2("launchctl", ["bootstrap", domainTarget(scope), file]);
+      if (bootstrap.code !== 0) {
+        const legacy = run2("launchctl", ["load", "-w", file]);
+        if (legacy.code !== 0) {
+          throw new Error(
+            `launchctl start failed: ${kick.stderr || bootstrap.stderr || legacy.stderr}`
+          );
+        }
       }
     }
+    for (let i = 0; i < 30; i += 1) {
+      if (launchdServicePid(scope) != null) return;
+      await sleep2(100);
+    }
+    throw new Error(
+      `daemon did not start within 3s \u2014 check logs at ${logs.err}`
+    );
   }
   async function stop() {
-    const res = run2("launchctl", ["kill", "SIGTERM", serviceTarget(scope)]);
-    if (res.code !== 0) {
+    const launchdPid = launchdServicePid(scope);
+    const bootout = run2("launchctl", ["bootout", serviceTarget(scope)]);
+    if (bootout.code !== 0) {
       run2("launchctl", ["unload", file]);
     }
+    if (launchdPid !== null) {
+      const exited = await waitForPidExit(launchdPid, 5e3);
+      if (!exited) {
+        try {
+          process.kill(launchdPid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    const inv = resolveTask0Invocation();
+    const orphans = findOrphanDaemonPids(inv.main, launchdPid);
+    for (const pid of orphans) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    if (orphans.length > 0) {
+      await sleep2(500);
+      for (const pid of orphans) {
+        if (pidAlive(pid)) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      }
+    }
   }
   async function status() {
     if (!fs30.existsSync(file)) return "absent";
@@ -6327,15 +6478,119 @@ function readCliVersion() {
   return cached2;
 }
 
+// src/core/project-watcher.ts
+init_node();
+import fs32 from "fs";
+import path31 from "path";
+var ProjectWatcher = class {
+  perProject = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  debounceMs;
+  onChange;
+  constructor(opts) {
+    this.onChange = opts.onChange;
+    this.debounceMs = opts.debounceMs ?? 300;
+  }
+  /**
+   * Reconcile watchers against the desired project list. Idempotent — call it
+   * whenever the daemon's project set changes (project_add / project_remove /
+   * project_set_enabled RPCs, or on reconnect with the latest config).
+   */
+  setProjects(projects) {
+    const wanted = /* @__PURE__ */ new Map();
+    for (const p of projects) {
+      if (p.enabled) wanted.set(p.name, p);
+    }
+    for (const [name, entry] of this.perProject) {
+      const target = wanted.get(name);
+      if (!target || path31.resolve(target.path) !== entry.rootPath) {
+        this.stopProject(name);
+      }
+    }
+    for (const [name, proj] of wanted) {
+      if (!this.perProject.has(name)) {
+        this.startProject(proj);
+      }
+    }
+  }
+  close() {
+    for (const name of [...this.perProject.keys()]) this.stopProject(name);
+    for (const [, t] of this.debounceTimers) clearTimeout(t);
+    this.debounceTimers.clear();
+  }
+  startProject(proj) {
+    const rootPath = path31.resolve(proj.path);
+    const projectYml = path31.join(rootPath, "task0.yml");
+    const cfg = readYaml(projectYml);
+    if (!cfg || typeof cfg.tasks_dir !== "string" || cfg.tasks_dir.length === 0) {
+      return;
+    }
+    const tasksDir = path31.resolve(rootPath, cfg.tasks_dir);
+    const watchers = [];
+    try {
+      const w = fs32.watch(tasksDir, { recursive: true }, () => this.notify(proj.name));
+      w.on("error", () => {
+      });
+      watchers.push(w);
+    } catch {
+    }
+    try {
+      const parentDir = path31.dirname(tasksDir);
+      const tasksDirName = path31.basename(tasksDir);
+      const tarName = tasksDirName + ".tar";
+      const w = fs32.watch(parentDir, (_event, filename) => {
+        if (!filename) return;
+        if (filename === tasksDirName || filename === tarName) {
+          this.notify(proj.name);
+        }
+      });
+      w.on("error", () => {
+      });
+      watchers.push(w);
+    } catch {
+    }
+    this.perProject.set(proj.name, { watchers, rootPath });
+  }
+  stopProject(name) {
+    const entry = this.perProject.get(name);
+    if (!entry) return;
+    for (const w of entry.watchers) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+    this.perProject.delete(name);
+    const timer = this.debounceTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.debounceTimers.delete(name);
+    }
+  }
+  notify(projectName) {
+    const prev = this.debounceTimers.get(projectName);
+    if (prev) clearTimeout(prev);
+    const t = setTimeout(() => {
+      this.debounceTimers.delete(projectName);
+      try {
+        this.onChange(projectName);
+      } catch (err) {
+        console.error(`project watcher onChange threw for ${projectName}:`, err);
+      }
+    }, this.debounceMs);
+    this.debounceTimers.set(projectName, t);
+  }
+};
+
 // src/commands/daemon.ts
-async function dispatchRpc(ws, id, method, params) {
+async function dispatchRpc(ws, id, method, params, notifyManifestChanged) {
   const handler = rpcHandlers[method];
   if (!handler) {
     sendRpc(ws, { type: "rpc_error", id, error: { code: "unknown_method", message: `unknown method: ${method}` } });
     return;
   }
   try {
-    const ctx = { notifyManifestChanged: () => pushManifest(ws) };
+    const ctx = { notifyManifestChanged };
     const result = await handler(params ?? {}, ctx);
     sendRpc(ws, { type: "rpc_response", id, result });
   } catch (error2) {
@@ -6382,6 +6637,9 @@ function buildManifest() {
   }
   return { type: "manifest", projects, tasks, scan_errors: scanErrors };
 }
+function currentWatchedProjects() {
+  return loadConfig().sources.filter((source2) => source2.type === "project").map((source2) => ({ name: source2.name, path: source2.path, enabled: source2.enabled }));
+}
 function pushManifest(ws) {
   if (ws.readyState !== ws.OPEN) return;
   const manifest = buildManifest();
@@ -6599,11 +6857,21 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
   let reconnectDelay = 1e3;
   let shouldRun = true;
   let activeWs = null;
+  let activeWatcher = null;
   function connect() {
     const ws = new WebSocket(wsUrl, {
       headers: { authorization: `Bearer ${identity.token}` }
     });
     activeWs = ws;
+    const watcher = new ProjectWatcher({
+      onChange: () => pushManifest(ws),
+      debounceMs: 300
+    });
+    activeWatcher = watcher;
+    const notifyManifestChanged = () => {
+      pushManifest(ws);
+      watcher.setProjects(currentWatchedProjects());
+    };
     ws.on("open", () => {
       reconnectDelay = 1e3;
       console.log(chalk19.green(`[${(/* @__PURE__ */ new Date()).toISOString()}] connected`));
@@ -6629,6 +6897,7 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
       const manifest = buildManifest();
       ws.send(JSON.stringify(manifest));
       console.log(chalk19.dim(`pushed manifest: ${manifest.projects.length} project(s)`));
+      watcher.setProjects(currentWatchedProjects());
       const sink = {
         send: (frame) => {
           if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(frame));
@@ -6651,7 +6920,7 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
       } else if (msg.type === "error") {
         console.error(chalk19.yellow(`server error: ${msg.message}`));
       } else if (msg.type === "rpc_request") {
-        void dispatchRpc(ws, msg.id, msg.method, msg.params);
+        void dispatchRpc(ws, msg.id, msg.method, msg.params, notifyManifestChanged);
       } else if (msg.type === "agent_run_resume_request") {
         const sent = replayAfterRanges(msg.ranges);
         if (sent > 0) {
@@ -6662,6 +6931,8 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
     ws.on("close", (code, reason) => {
       activeWs = null;
       bindAgentRunFrameSink(null);
+      watcher.close();
+      if (activeWatcher === watcher) activeWatcher = null;
       const reasonText = reason.toString("utf-8") || "no reason";
       console.log(chalk19.yellow(`[${(/* @__PURE__ */ new Date()).toISOString()}] disconnected (code=${code}, ${reasonText})`));
       if (code === 4001) {
@@ -6679,6 +6950,10 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
   }
   const shutdown = () => {
     shouldRun = false;
+    try {
+      activeWatcher?.close();
+    } catch {
+    }
     try {
       activeWs?.close(1e3, "shutdown");
     } catch {
@@ -6807,8 +7082,8 @@ function fail7(message, code = 1) {
   console.error(chalk20.red(message));
   process.exit(code);
 }
-async function callServer(path32, init = {}) {
-  const url = `${serverBase2()}${path32}`;
+async function callServer(path33, init = {}) {
+  const url = `${serverBase2()}${path33}`;
   let auth;
   try {
     auth = adminAuthHeader();
@@ -7313,8 +7588,8 @@ automation.command("runs <id>").description("List recent runs for an automation"
 
 // src/commands/profile.ts
 init_node();
-import fs32 from "fs";
-import path31 from "path";
+import fs33 from "fs";
+import path32 from "path";
 import { Command as Command23 } from "commander";
 import chalk23 from "chalk";
 import yaml11 from "js-yaml";
@@ -7327,19 +7602,19 @@ function fail9(msg) {
   process.exit(1);
 }
 function readDaemonAt(dir) {
-  const file = path31.join(dir, "daemon.json");
-  if (!fs32.existsSync(file)) return null;
+  const file = path32.join(dir, "daemon.json");
+  if (!fs33.existsSync(file)) return null;
   try {
-    return JSON.parse(fs32.readFileSync(file, "utf-8"));
+    return JSON.parse(fs33.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function readProfileApiUrl(name) {
-  const file = path31.join(profileDir(name), "config.yml");
-  if (!fs32.existsSync(file)) return void 0;
+  const file = path32.join(profileDir(name), "config.yml");
+  if (!fs33.existsSync(file)) return void 0;
   try {
-    const data = yaml11.load(fs32.readFileSync(file, "utf-8"));
+    const data = yaml11.load(fs33.readFileSync(file, "utf-8"));
     return data?.api_url;
   } catch {
     return void 0;
@@ -7368,10 +7643,10 @@ profile2.command("add <name>").description("Create a new profile directory (use
     fail9(`"${DEFAULT_PROFILE_NAME}" is reserved; it always exists.`);
   }
   const dir = profileDir(name);
-  if (fs32.existsSync(dir)) {
+  if (fs33.existsSync(dir)) {
     fail9(`Profile "${name}" already exists at ${dir}.`);
   }
-  fs32.mkdirSync(dir, { recursive: true });
+  fs33.mkdirSync(dir, { recursive: true });
   const prev = process.env.TASK0_PROFILE;
   process.env.TASK0_PROFILE = name;
   try {
@@ -7395,14 +7670,14 @@ profile2.command("remove <name>").description('Delete a profile directory (refus
     fail9(`"${DEFAULT_PROFILE_NAME}" cannot be removed.`);
   }
   const dir = profileDir(name);
-  if (!fs32.existsSync(dir)) {
+  if (!fs33.existsSync(dir)) {
     fail9(`Profile "${name}" not found.`);
   }
   const current = currentProfileName();
   if (current === name && !opts.force) {
     fail9(`Profile "${name}" is current. Re-run with --force to remove it.`);
   }
-  fs32.rmSync(dir, { recursive: true, force: true });
+  fs33.rmSync(dir, { recursive: true, force: true });
   if (current === name) {
     writeCurrentProfile(null);
     console.log(chalk23.dim('Current profile reset to "default".'));
@@ -7413,7 +7688,7 @@ profile2.command("use <name>").description("Set the current profile").action((na
   if (!isValidProfileName(name)) {
     fail9(`Invalid profile name "${name}".`);
   }
-  if (!fs32.existsSync(profileDir(name))) {
+  if (!fs33.existsSync(profileDir(name))) {
     const names = listProfileNames();
     fail9(`Profile "${name}" not found. Available: ${names.join(", ")}.`);
   }
@@ -7448,7 +7723,7 @@ profile2.command("show [name]").description("Show a profile's configuration and
     fail9(`Invalid profile name "${target}".`);
   }
   const dir = profileDir(target);
-  if (!fs32.existsSync(dir)) {
+  if (!fs33.existsSync(dir)) {
     fail9(`Profile "${target}" not found.`);
   }
   const current = currentProfileName();
@@ -7458,7 +7733,7 @@ profile2.command("show [name]").description("Show a profile's configuration and
   const effective = envOverride ?? apiUrl;
   console.log(`${chalk23.bold(target)}${current === target ? chalk23.green(" (current)") : ""}`);
   console.log(`  dir:        ${dir}`);
-  console.log(`  config:     ${path31.join(dir, "config.yml")}`);
+  console.log(`  config:     ${path32.join(dir, "config.yml")}`);
   if (envOverride && apiUrl && envOverride !== apiUrl) {
     console.log(`  api_url:    ${envOverride} ${chalk23.dim("(TASK0_API_URL env, overrides profile)")}`);
     console.log(`              ${chalk23.dim(`profile: ${apiUrl}`)}`);

package/package.json

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