@task0/cli 0.10.0 → 0.11.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
@@ -6327,15 +6327,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 +6486,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 +6706,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 +6746,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 +6769,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 +6780,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 +6799,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 +6931,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 +7437,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 +7451,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 +7492,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 +7519,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 +7537,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 +7572,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 +7582,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.11.0",
   "description": "task0 — task-centric agent workflow CLI",
   "homepage": "https://github.com/cy0-labs/task0#readme",
   "repository": {