@integrity-labs/agt-cli 0.7.6 → 0.7.8

package/dist/lib/manager-worker.js

@@ -6,9 +6,10 @@ import {
   getFramework,
   getHostId,
   provision,
+  provisionStopHook,
   requireHost,
   resolveChannels
-} from "../chunk-VJ7ZRBAJ.js";
+} from "../chunk-B47JW4MM.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -20,10 +21,42 @@ import {
 
 // src/lib/manager-worker.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2, rmSync, readdirSync, statSync, unlinkSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2, rmSync, readdirSync, statSync, unlinkSync } from "fs";
 import https from "https";
 import { join as join2 } from "path";
 
+// src/lib/mcp-sanitize.ts
+import { readFileSync, writeFileSync } from "fs";
+function sanitizeMcpJson(mcpConfigPath, apiHost) {
+  try {
+    const mcpRaw = JSON.parse(readFileSync(mcpConfigPath, "utf-8"));
+    const servers = mcpRaw.mcpServers;
+    if (!servers) return false;
+    let changed = false;
+    for (const [key, val] of Object.entries(servers)) {
+      if (typeof val?.url !== "string") continue;
+      if (val.url.startsWith("/")) {
+        if (apiHost) {
+          val.url = `${apiHost}${val.url}`;
+          changed = true;
+        } else {
+          delete servers[key];
+          changed = true;
+          continue;
+        }
+      }
+      if (!val.type) {
+        val.type = "sse";
+        changed = true;
+      }
+    }
+    if (changed) writeFileSync(mcpConfigPath, JSON.stringify(mcpRaw, null, 2));
+    return changed;
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/gateway-client.ts
 import { EventEmitter } from "events";
 import WebSocket from "ws";
@@ -297,7 +330,7 @@ var GatewayClientPool = class extends EventEmitter {
 import { spawn, execSync } from "child_process";
 import { join } from "path";
 import { homedir } from "os";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
 var sessions = /* @__PURE__ */ new Map();
 function startPersistentSession(config2) {
   const existing = sessions.get(config2.codeName);
@@ -318,6 +351,7 @@ function startPersistentSession(config2) {
 }
 function spawnSession(config2, session) {
   const { codeName, projectDir, mcpConfigPath, claudeMdPath, channels, devChannels, log: log2 } = config2;
+  sanitizeMcpJson(mcpConfigPath);
   const args = [];
   if (channels.length > 0) {
     args.push("--channels", ...channels);
@@ -346,7 +380,7 @@ function spawnSession(config2, session) {
   let envPrefix = "";
   if (existsSync(envIntegrationsPath)) {
     try {
-      const envContent = readFileSync(envIntegrationsPath, "utf-8");
+      const envContent = readFileSync2(envIntegrationsPath, "utf-8");
       const envVars = envContent.split("\n").filter((line) => line && !line.startsWith("#") && line.includes("=")).map((line) => {
         const eqIdx = line.indexOf("=");
         const key = line.slice(0, eqIdx);
@@ -490,6 +524,32 @@ function resetRestartCount(codeName) {
   const session = sessions.get(codeName);
   if (session) session.restartCount = 0;
 }
+async function stopAllSessionsAndWait(log2, opts) {
+  const codeNames = [...sessions.keys()];
+  if (codeNames.length === 0) return;
+  const exitPromises = [];
+  for (const codeName of codeNames) {
+    const session = sessions.get(codeName);
+    const proc = session?.process;
+    stopPersistentSession(codeName, log2);
+    if (proc && !proc.killed && proc.exitCode === null) {
+      exitPromises.push(
+        new Promise((resolve) => {
+          proc.on("close", resolve);
+          proc.on("error", resolve);
+        })
+      );
+    }
+  }
+  if (exitPromises.length === 0) return;
+  await Promise.race([
+    Promise.all(exitPromises),
+    new Promise((resolve) => setTimeout(() => {
+      log2(`[persistent-session] Shutdown timeout (${opts.timeoutMs}ms), force-killing remaining sessions`);
+      resolve();
+    }, opts.timeoutMs))
+  ]);
+}
 function getProjectDir2(codeName) {
   return join(homedir(), ".augmented", codeName, "project");
 }
@@ -934,14 +994,14 @@ function checkClaudeAuth(execFileSync) {
 }
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync2(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync3(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveGatewayPorts(ports) {
   mkdirSync(AUGMENTED_DIR, { recursive: true });
-  writeFileSync(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
+  writeFileSync2(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
 }
 function allocatePort(codeName) {
   const ports = loadGatewayPorts();
@@ -967,7 +1027,7 @@ var STATE_FILE = join2(process.env["HOME"] ?? "/tmp", ".augmented", "manager-sta
 function send(msg) {
   if (msg.type === "state-update") {
     try {
-      writeFileSync(STATE_FILE, JSON.stringify(msg.state, null, 2));
+      writeFileSync2(STATE_FILE, JSON.stringify(msg.state, null, 2));
     } catch {
     }
   }
@@ -989,7 +1049,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -1000,7 +1060,7 @@ async function migrateToProfiles() {
   const sharedConfigPath = join2(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync2(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync3(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -1024,8 +1084,8 @@ async function migrateToProfiles() {
     const authFile = join2(sharedAuthDir, "auth-profiles.json");
     if (existsSync2(authFile)) {
       mkdirSync(profileAuthDir, { recursive: true });
-      const authContent = readFileSync2(authFile, "utf-8");
-      writeFileSync(join2(profileAuthDir, "auth-profiles.json"), authContent);
+      const authContent = readFileSync3(authFile, "utf-8");
+      writeFileSync2(join2(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -1063,7 +1123,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync2(join2(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync3(join2(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -1075,7 +1135,7 @@ function isGatewayHung(codeName) {
   const jobsPath = join2(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   if (!existsSync2(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync2(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync3(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
@@ -1116,11 +1176,11 @@ async function ensureGatewayRunning(codeName, adapter) {
           const homeDir = process.env["HOME"] ?? "/tmp";
           const configPath = join2(homeDir, `.openclaw-${codeName}`, "openclaw.json");
           if (existsSync2(configPath)) {
-            const cfg = JSON.parse(readFileSync2(configPath, "utf-8"));
+            const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
-              writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+              writeFileSync2(configPath, JSON.stringify(cfg, null, 2));
             }
           }
         } catch {
@@ -1142,10 +1202,10 @@ async function ensureGatewayRunning(codeName, adapter) {
       const homeDir = process.env["HOME"] ?? "/tmp";
       const configPath = join2(homeDir, `.openclaw-${codeName}`, "openclaw.json");
       if (existsSync2(configPath)) {
-        const cfg = JSON.parse(readFileSync2(configPath, "utf-8"));
+        const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
-        writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+        writeFileSync2(configPath, JSON.stringify(cfg, null, 2));
       }
     } catch {
     }
@@ -1308,10 +1368,13 @@ async function pollCycle() {
     const currentIds = new Set(agents.map((a) => a.agent_id));
     for (const prev of state.agents) {
       if (!currentIds.has(prev.agentId)) {
-        log(`Agent '${prev.codeName}' unassigned from host`);
+        log(`Agent '${prev.codeName}' removed from host (deleted or unassigned)`);
         const adapter = resolveAgentFramework(prev.codeName);
-        clearAgentCaches(prev.agentId, prev.codeName);
         await stopGatewayIfRunning(prev.codeName, adapter);
+        freePort(prev.codeName);
+        const agentDir = join2(config.configDir, prev.codeName, "provision");
+        await cleanupAgentFiles(prev.codeName, agentDir);
+        clearAgentCaches(prev.agentId, prev.codeName);
       }
     }
     await healthCheckGateways(agentStates);
@@ -1542,7 +1605,7 @@ async function processAgent(agent, agentStates) {
       const fileNames = changedFiles.map((f) => f.relativePath).join(", ");
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
-        writeFileSync(join2(agentDir, file.relativePath), file.content);
+        writeFileSync2(join2(agentDir, file.relativePath), file.content);
       }
       lastProvisionAt = (/* @__PURE__ */ new Date()).toISOString();
       knownVersions.set(agent.agent_id, { charterVersion, toolsVersion });
@@ -1734,6 +1797,44 @@ async function processAgent(agent, agentStates) {
         }
         knownIntegrationHashes.set(agent.agent_id, intHash);
         log(`Integrations provisioned for '${agent.code_name}' (${integrations.length} integration(s))`);
+        const managedIntegrations = integrations.filter((i) => i.auth_type === "managed");
+        if (managedIntegrations.length > 0 && frameworkAdapter.writeMcpServer) {
+          try {
+            const toolkitData = await api.post("/host/managed-toolkits", { agent_ids: [agent.agent_id] });
+            const expectedServerIds = /* @__PURE__ */ new Set();
+            for (const tk of toolkitData.toolkits) {
+              if (tk.agent_id !== agent.agent_id) continue;
+              const serverId = tk.toolkit_id.replace(/\//g, "-");
+              expectedServerIds.add(serverId);
+              const proxyUrl = tk.proxy_url.startsWith("/") ? `${requireHost()}${tk.proxy_url}` : tk.proxy_url;
+              frameworkAdapter.writeMcpServer(agent.code_name, serverId, {
+                url: proxyUrl
+              });
+              log(`[managed-toolkit] ${agent.code_name}: ${tk.toolkit_name} \u2192 ${proxyUrl}`);
+            }
+            if (frameworkAdapter.removeMcpServer) {
+              try {
+                const { readFileSync: readFileSync4 } = await import("fs");
+                const { join: join3 } = await import("path");
+                const { homedir: homedir2 } = await import("os");
+                const mcpPath = join3(homedir2(), ".augmented", "agents", agent.code_name, "provision", ".mcp.json");
+                const mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+                if (mcpConfig.mcpServers) {
+                  const managedPrefixes = ["composio-", "one-", "nango-", "paragon-"];
+                  for (const key of Object.keys(mcpConfig.mcpServers)) {
+                    if (managedPrefixes.some((p) => key.startsWith(p)) && !expectedServerIds.has(key)) {
+                      frameworkAdapter.removeMcpServer(agent.code_name, key);
+                      log(`[managed-toolkit] Removed stale MCP server '${key}' for '${agent.code_name}'`);
+                    }
+                  }
+                }
+              } catch {
+              }
+            }
+          } catch (err) {
+            log(`[managed-toolkit] Failed to provision for '${agent.code_name}': ${err.message}`);
+          }
+        }
         needsGatewayRestart = true;
         const hasLcm = integrations.some((i) => i.definition_id === "lossless-claw");
         if (hasLcm && !losslessClawInstalled.get(agent.code_name)) {
@@ -1980,8 +2081,6 @@ async function processAgent(agent, agentStates) {
       agentDisplayName: agent.display_name
     });
   }
-  const ccInFlight = agentFw === "claude-code" ? claudeTaskConcurrency.get(agent.code_name) ?? 0 : null;
-  log(`[${agent.code_name}] Harvest gate: gatewayRunning=${gatewayRunning} gatewayPort=${gatewayPort} tasks=${tasks.length} fw=${agentFw}${ccInFlight !== null ? ` claude-p=${ccInFlight}/${MAX_CLAUDE_CONCURRENCY}` : ""}`);
   if (agentFw === "openclaw" && gatewayRunning && gatewayPort && tasks.length > 0) {
     const lastHarvest = lastHarvestAt.get(agent.code_name) ?? 0;
     if (Date.now() - lastHarvest >= HARVEST_INTERVAL_MS) {
@@ -2003,7 +2102,7 @@ async function processAgent(agent, agentStates) {
           const jobsPath = join2(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
           if (existsSync2(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync2(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync3(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -2016,7 +2115,20 @@ async function processAgent(agent, agentStates) {
             }
           }
         } else if (agentFw === "claude-code") {
-          fireClaudeWorkTrigger(agent.code_name, agent.agent_id, boardItems);
+          if (sessionMode === "persistent") {
+            if (isSessionHealthy(agent.code_name)) {
+              const todayItem = boardItems.find((b) => b.status === "today");
+              const taskHint = todayItem ? ` Top item: "${todayItem.title}" (priority ${todayItem.priority}).` : "";
+              injectMessage(agent.code_name, "task", `New work triggered. Check your kanban board with kanban_list and pick up the next item.${taskHint}`, {
+                task_name: "kanban-work-trigger"
+              });
+              log(`[persistent-session] Work trigger injected for '${agent.code_name}'`);
+            } else {
+              log(`[persistent-session] Work trigger skipped for '${agent.code_name}' \u2014 session not yet healthy`);
+            }
+          } else {
+            fireClaudeWorkTrigger(agent.code_name, agent.agent_id, boardItems);
+          }
         }
       }
     }
@@ -2147,7 +2259,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
   const indexPath = join2(sessionsDir, "sessions.json");
   if (!existsSync2(indexPath)) return;
   try {
-    const raw = readFileSync2(indexPath, "utf-8");
+    const raw = readFileSync3(indexPath, "utf-8");
     const index = JSON.parse(raw);
     const cronRunKeys = Object.keys(index).filter((k) => k.includes(":cron:") && k.includes(":run:")).map((k) => ({
       key: k,
@@ -2192,7 +2304,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         }
       }
     }
-    writeFileSync(indexPath, JSON.stringify(index));
+    writeFileSync2(indexPath, JSON.stringify(index));
     if (toDelete.length > 0) {
       log(`Cleaned ${toDelete.length} cron session(s) and ${deletedFiles} file(s) from ${sessionsDir}`);
     }
@@ -2203,7 +2315,7 @@ var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
   if (!existsSync2(jobsPath)) return;
   try {
-    const raw = readFileSync2(jobsPath, "utf-8");
+    const raw = readFileSync3(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
@@ -2228,7 +2340,7 @@ function clearStaleCronRunState(jobsPath) {
       }
     }
     if (changed) {
-      writeFileSync(jobsPath, JSON.stringify(data, null, 2));
+      writeFileSync2(jobsPath, JSON.stringify(data, null, 2));
     }
   } catch {
   }
@@ -2331,6 +2443,7 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir(codeName);
   const mcpConfigPath = join2(projectDir, ".mcp.json");
+  sanitizeMcpJson(mcpConfigPath, requireHost());
   try {
     const claudeMdPath = join2(projectDir, "CLAUDE.md");
     const claudeArgs = [
@@ -2461,6 +2574,11 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     if (persistentSessionAgents.has(codeName)) {
       log(`[persistent-session] Session for '${codeName}' is unhealthy, will restart`);
     }
+    try {
+      provisionStopHook(codeName);
+    } catch (err) {
+      log(`[persistent-session] Failed to provision Stop hook for '${codeName}': ${err.message}`);
+    }
     startPersistentSession({
       codeName,
       agentId: agent.agent_id,
@@ -2502,6 +2620,21 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
         }
       }
       log(`[persistent-session] Injecting task '${task.name}' into '${codeName}'`);
+      const projectDir2 = getProjectDir2(codeName);
+      const markerDir = join2(projectDir2, ".claude");
+      const markerPath = join2(markerDir, ".agt-pending-task.json");
+      try {
+        mkdirSync(markerDir, { recursive: true });
+        writeFileSync2(markerPath, JSON.stringify({
+          agent_id: agent.agent_id,
+          task_id: task.taskId,
+          template_id: task.templateId,
+          task_name: task.name,
+          injected_at: (/* @__PURE__ */ new Date()).toISOString()
+        }), "utf-8");
+      } catch (err) {
+        log(`[persistent-session] Failed to write task marker for '${codeName}': ${err.message}`);
+      }
       const injected = await injectMessage(codeName, "task", prompt, {
         task_id: task.taskId,
         template_id: task.templateId,
@@ -2545,8 +2678,23 @@ var realtimeDriftStarted = false;
 var realtimeKanbanStarted = false;
 var realtimeAssignStarted = false;
 var realtimeConfigStarted = false;
+var realtimeSubscribedAgentIds = /* @__PURE__ */ new Set();
 function ensureRealtimeStarted(agentStates) {
-  if (realtimeStarted) return;
+  const currentActiveIds = new Set(
+    agentStates.filter((a) => a.status === "active").map((a) => a.agentId)
+  );
+  if (realtimeStarted) {
+    const sameSize = currentActiveIds.size === realtimeSubscribedAgentIds.size;
+    const sameMembers = sameSize && [...currentActiveIds].every((id) => realtimeSubscribedAgentIds.has(id));
+    if (sameMembers) return;
+    log("[realtime] Agent set changed \u2014 reconnecting subscriptions");
+    stopRealtimeChat();
+    realtimeStarted = false;
+    realtimeDriftStarted = false;
+    realtimeAssignStarted = false;
+    realtimeConfigStarted = false;
+    realtimeKanbanStarted = false;
+  }
   const activeAgentIds = agentStates.filter((a) => a.status === "active").map((a) => a.agentId);
   if (activeAgentIds.length === 0) return;
   const apiKey = process.env["AGT_API_KEY"];
@@ -2590,6 +2738,7 @@ function ensureRealtimeStarted(agentStates) {
       log
     });
     realtimeStarted = true;
+    realtimeSubscribedAgentIds = new Set(activeAgentIds);
     log(`[realtime-chat] Started for ${activeAgentIds.length} agent(s)`);
   }).catch((err) => {
     log(`[realtime-chat] Failed to start: ${err.message}`);
@@ -3022,7 +3171,7 @@ function getBuiltInSkillContent(skillId) {
     ];
     for (const candidate of candidates) {
       if (existsSync2(candidate)) {
-        const content = readFileSync2(candidate, "utf-8");
+        const content = readFileSync3(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -3540,16 +3689,50 @@ function scheduleNext() {
     void pollCycle().then(scheduleNext);
   }, config.intervalMs);
 }
+async function killAllAgtTmuxSessions() {
+  try {
+    const { stdout: output } = await execFilePromiseLong(
+      "tmux",
+      ["list-sessions", "-F", "#{session_name}"],
+      { timeout: 2e3, stdin: "ignore" }
+    );
+    const sessions2 = output.trim().split("\n").filter((s) => s.startsWith("agt-"));
+    for (const session of sessions2) {
+      try {
+        await execFilePromiseLong("tmux", ["kill-session", "-t", session], {
+          timeout: 2e3,
+          stdin: "ignore"
+        });
+        log(`Killed tmux session '${session}'`);
+      } catch {
+      }
+    }
+    if (sessions2.length > 0) {
+      log(`Cleaned up ${sessions2.length} agt-* tmux session(s)`);
+    }
+  } catch {
+  }
+}
 async function stopPolling() {
   running = false;
   if (pollTimer) {
     clearTimeout(pollTimer);
     pollTimer = null;
   }
+  const shutdownTimer = setTimeout(() => {
+    log("Shutdown timeout exceeded (5s), forcing exit");
+    process.exit(1);
+  }, 5e3);
+  shutdownTimer.unref();
   stopCaffeinate();
   stopRealtimeChat();
   stopGatewayPool();
+  log("Stopping persistent sessions...");
+  await stopAllSessionsAndWait(log, { timeoutMs: 4e3 });
+  log("Stopping gateway processes...");
   await stopAllGateways();
+  await killAllAgtTmuxSessions();
+  clearTimeout(shutdownTimer);
 }
 function startManager(opts) {
   config = opts;