@integrity-labs/agt-cli 0.28.204 → 0.28.206

package/dist/lib/manager-worker.js

@@ -28,7 +28,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-DKVV2REL.js";
+} from "../chunk-WALP3HBE.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -70,7 +70,7 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-2A2EV3B3.js";
+} from "../chunk-GWBOA7ZY.js";
 import {
   CONVERSATION_FAILURE_CATEGORIES,
   DEFAULT_FRAMEWORK,
@@ -114,7 +114,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   sumTranscriptUsageInWindow
-} from "../chunk-2AWUVRIX.js";
+} from "../chunk-ELBYWACS.js";
 import {
   parsePsRows,
   reapOrphanChannelMcps
@@ -1804,6 +1804,116 @@ function isDirectChatMessageExpired(createdAt, nowMs, maxAgeMs) {
   return nowMs - created > maxAgeMs;
 }
 
+// src/lib/session-tool-probe.ts
+function classifyMcpServer(entry) {
+  if (!entry || typeof entry !== "object") return "unknown";
+  const e = entry;
+  if (typeof e.command === "string") return "stdio";
+  if (typeof e.url === "string") return "http";
+  return "unknown";
+}
+function splitServerKeysByKind(mcpJson, serverKeys) {
+  const servers = mcpJson?.mcpServers ?? {};
+  const stdio = [];
+  const http = [];
+  for (const key of serverKeys) {
+    const kind = classifyMcpServer(servers[key]);
+    if (kind === "stdio") stdio.push(key);
+    else if (kind === "http") http.push(key);
+  }
+  return { stdio, http };
+}
+function computeSessionToolBindStatus(input) {
+  const { stdioServerKeys, httpServerKeys, missingStdioKeys, httpReachable, httpSessionLoaded } = input;
+  if (stdioServerKeys.length === 0 && httpServerKeys.length === 0) return "unknown";
+  if (stdioServerKeys.some((k) => missingStdioKeys.has(k))) return "missing";
+  let anyHttpUnconfirmed = false;
+  for (const k of httpServerKeys) {
+    const reachable = httpReachable.get(k);
+    if (reachable === false) return "unreachable";
+    if (reachable === void 0) {
+      anyHttpUnconfirmed = true;
+    } else if (!httpSessionLoaded) {
+      anyHttpUnconfirmed = true;
+    }
+  }
+  if (anyHttpUnconfirmed && stdioServerKeys.length === 0) return "unknown";
+  return "bound";
+}
+
+// src/lib/session-tool-bind-runner.ts
+var DEFAULT_INTERVAL_MS2 = 60 * 60 * 1e3;
+var DEFAULT_MAX_PER_RUN2 = 25;
+function sanitizeServerKey(definitionId) {
+  return definitionId.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+}
+function resolveIntegrationServerKeys(definitionId, declaredKeys, hint) {
+  const declared = new Set(declaredKeys);
+  const candidates = [hint, definitionId, sanitizeServerKey(definitionId)].filter(
+    (k) => typeof k === "string" && k.length > 0
+  );
+  const out = /* @__PURE__ */ new Set();
+  for (const c of candidates) if (declared.has(c)) out.add(c);
+  return [...out];
+}
+function isDue2(last, now, intervalMs) {
+  if (!last) return true;
+  const t = Date.parse(last);
+  if (Number.isNaN(t)) return true;
+  return now - t >= intervalMs;
+}
+async function runSessionToolBindProbes(integrations, options) {
+  const now = (options.now?.() ?? /* @__PURE__ */ new Date()).getTime();
+  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS2;
+  const maxPerRun = options.maxPerRun ?? DEFAULT_MAX_PER_RUN2;
+  const due = integrations.filter((i) => isDue2(i.last_session_tool_bind_at, now, intervalMs)).sort((a, b) => {
+    const ta = a.last_session_tool_bind_at ? Date.parse(a.last_session_tool_bind_at) : 0;
+    const tb = b.last_session_tool_bind_at ? Date.parse(b.last_session_tool_bind_at) : 0;
+    return ta - tb;
+  });
+  const batch = due.slice(0, maxPerRun);
+  const declaredKeys = Object.keys(options.mcpJson?.mcpServers ?? {});
+  const reports = [];
+  let skipped = 0;
+  let probed = 0;
+  for (const integ of batch) {
+    const keys = resolveIntegrationServerKeys(
+      integ.definition_id,
+      declaredKeys,
+      integ.mcp_server_key
+    );
+    if (keys.length === 0) {
+      skipped += 1;
+      continue;
+    }
+    probed += 1;
+    const { stdio, http } = splitServerKeysByKind(options.mcpJson, keys);
+    const httpReachable = /* @__PURE__ */ new Map();
+    for (const key of http) {
+      let reachable;
+      try {
+        reachable = await options.probeHttp(key);
+      } catch {
+        reachable = void 0;
+      }
+      if (reachable !== void 0) httpReachable.set(key, reachable);
+    }
+    const status = computeSessionToolBindStatus({
+      stdioServerKeys: stdio,
+      httpServerKeys: http,
+      missingStdioKeys: options.missingStdioKeys,
+      httpReachable,
+      httpSessionLoaded: options.httpSessionLoaded ?? false
+    });
+    if (status === "unknown") {
+      skipped += 1;
+      continue;
+    }
+    reports.push({ integration_id: integ.id, scope: integ.scope, status });
+  }
+  return { reports, due: due.length, probed, skipped };
+}
+
 // ../../packages/core/dist/host-config/capture.js
 import { createHash as createHash3 } from "crypto";
 var NON_SECRET_ENV_GATES = [
@@ -6504,6 +6614,76 @@ async function runAgentConnectivityProbes(agent, integrations, projectDir) {
     );
   }
 }
+async function runAgentSessionToolBindProbes(agent, integrations, projectDir) {
+  if (integrations.length === 0) return;
+  let mcpJson = null;
+  try {
+    mcpJson = JSON.parse(readFileSync14(join16(projectDir, ".mcp.json"), "utf-8"));
+  } catch {
+    return;
+  }
+  if (!mcpJson?.mcpServers || Object.keys(mcpJson.mcpServers).length === 0) return;
+  const isolated = isolationMode(agent.code_name) === "docker";
+  let missingStdioKeys = /* @__PURE__ */ new Set();
+  try {
+    const psOutput = isolated ? syncExecFile("docker", ["exec", `agt-${agent.code_name}`, "ps", "-eo", "pid,ppid,args"], {
+      encoding: "utf-8",
+      timeout: 8e3
+    }) : syncExecFile("ps", ["-eo", "pid,ppid,args"], { encoding: "utf-8", timeout: 5e3 });
+    missingStdioKeys = new Set(
+      findMissingMcpServers({
+        rows: parsePsRows(psOutput),
+        codeName: agent.code_name,
+        mcpJson,
+        inContainer: isolated
+      })
+    );
+  } catch {
+  }
+  const probeEnv = buildProbeEnv(projectDir);
+  const probeDeps = buildConnectivityProbeDeps(projectDir, probeEnv);
+  const probeHttp = async (serverKey) => {
+    if (!probeDeps.mcpProbe) return void 0;
+    const outcome = await probeDeps.mcpProbe({ serverKey, definitionId: serverKey });
+    if (outcome.status === "ok") return true;
+    if (outcome.status === "down") return false;
+    return void 0;
+  };
+  let httpSessionLoaded = false;
+  try {
+    const sessionStartedMs = getSessionState(agent.code_name)?.startedAt ?? null;
+    const mcpMtimeMs = statSync4(join16(projectDir, ".mcp.json")).mtimeMs;
+    httpSessionLoaded = sessionStartedMs != null && sessionStartedMs >= mcpMtimeMs;
+  } catch {
+  }
+  const intervalSec = Number(process.env.AGT_CONNECTIVITY_PROBE_INTERVAL_SECONDS) || 3600;
+  const result = await runSessionToolBindProbes(
+    integrations.map((i) => ({
+      id: i.id,
+      definition_id: i.definition_id,
+      scope: i.scope,
+      last_session_tool_bind_at: i.last_session_tool_bind_at ?? null,
+      // Server-key hint for managed/remote-MCP kinds; the runner also tries the
+      // raw + sanitised definition_id against the real `.mcp.json` keys.
+      mcp_server_key: deriveMcpServerKey({
+        definitionId: i.definition_id,
+        sourceType: i.source_type ?? null,
+        authType: i.auth_type,
+        connectivityTest: i.connectivity_test ?? null
+      })
+    })),
+    { mcpJson, missingStdioKeys, probeHttp, httpSessionLoaded, intervalMs: intervalSec * 1e3 }
+  );
+  if (result.reports.length > 0) {
+    await api.post("/host/session-tool-bind", {
+      agent_id: agent.agent_id,
+      results: result.reports
+    });
+    log(
+      `Session-tool-bind probe for '${agent.code_name}': probed=${result.probed} reported=${result.reports.length} due=${result.due}`
+    );
+  }
+}
 function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason, gateReason = breakerReason) {
   const gate = restartGateFor(codeName, gateReason);
   if (gate !== "bypass" && gate !== "proceed") {
@@ -6686,7 +6866,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.204" : "dev";
+var agtCliVersion = true ? "0.28.206" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -7595,7 +7775,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-OXQGFIXK.js");
+      const { collectDiagnostics } = await import("../persistent-session-6662WBSH.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -7743,7 +7923,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-T5Z5KPVX.js");
+      } = await import("../responsiveness-probe-TOLTTG6I.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -7775,7 +7955,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-T5Z5KPVX.js");
+        } = await import("../responsiveness-probe-TOLTTG6I.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -9135,7 +9315,7 @@ async function processAgent(agent, agentStates) {
         log(`OAuth token refresh failed for '${agent.code_name}/${integration.definition_id}': ${err.message}`);
       }
     }
-    if (process.env.AGT_CONNECTIVITY_PROBE_ENABLED === "true") {
+    if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
         const probeProjectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
@@ -9143,6 +9323,14 @@ async function processAgent(agent, agentStates) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
       }
     }
+    if (hostFlagStore().getBoolean("session-tool-probe")) {
+      try {
+        const probeProjectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
+        await runAgentSessionToolBindProbes(agent, integrations, probeProjectDir);
+      } catch (err) {
+        log(`Session-tool-bind probe failed for '${agent.code_name}': ${err.message}`);
+      }
+    }
     if (integrations.length > 0) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
@@ -10794,7 +10982,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-H5UNK3LX.js");
+  } = await import("../claude-pair-runtime-Q4Q2OTTV.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));