chainlesschain 0.162.197 → 0.162.200

package/src/runtime/agent-runtime.js

@@ -19,11 +19,16 @@ import { attachTopicHandlers } from "../gateways/ws/topic-handler-attachment.js"
 import { PtyManager } from "../gateways/terminal/PtyManager.js";
 import { createTerminalHandlers } from "../gateways/terminal/terminal-handlers.js";
 import { createWebUIServer } from "../gateways/ui/web-ui-server.js";
-import { MCPClient, MCPServerConfig } from "../harness/mcp-client.js";
+import {
+  MCPClient,
+  MCPServerConfig,
+  inferTransport,
+} from "../harness/mcp-client.js";
 import sharedManagedToolPolicy from "./coding-agent-managed-tool-policy.cjs";
 import { findProjectRoot, loadProjectConfig } from "../lib/project-detector.js";
 import { loadConfig } from "../lib/config-manager.js";
 import { collectWorkspacePluginBinSandboxPolicy } from "../lib/plugin-runtime/bin.js";
+import { issueMcpStdioExecutionAuthority } from "../lib/mcp-stdio-execution-authority.js";
 
 const {
   DEFAULT_ALLOWED_MCP_SERVER_NAMES,
@@ -266,7 +271,15 @@ export class AgentRuntime {
             }
             for (const [name, cfg] of entries) {
               try {
-                await bundleMcpClient.connect(name, cfg);
+                const authorizedConfig = { ...cfg };
+                authorizedConfig.mcpStdioExecutionAuthority =
+                  issueMcpStdioExecutionAuthority({
+                    serverName: name,
+                    config: authorizedConfig,
+                    approvalKind: "explicit-config",
+                    approvalSource: `agent-bundle:${path.resolve(this.policy.bundlePath)}`,
+                  });
+                await bundleMcpClient.connect(name, authorizedConfig);
               } catch (mcpErr) {
                 runtimeLogger.log(
                   chalk.yellow(
@@ -779,7 +792,17 @@ export class AgentRuntime {
 
     for (const server of eligibleServers) {
       try {
-        await mcpClient.connect(server.name, server);
+        const authorizedServer = { ...server };
+        if (inferTransport(authorizedServer) === "stdio") {
+          authorizedServer.mcpStdioExecutionAuthority =
+            issueMcpStdioExecutionAuthority({
+              serverName: server.name,
+              config: authorizedServer,
+              approvalKind: "registered-config",
+              approvalSource: `${server.configScope || "user"}:${server.configSource || "database"}:${server.name}`,
+            });
+        }
+        await mcpClient.connect(server.name, authorizedServer);
         connectedCount += 1;
       } catch (err) {
         options.logger?.log?.(

package/src/runtime/cleanup-deadline.js

@@ -0,0 +1,143 @@
+import { performance } from "node:perf_hooks";
+
+const HOST_CLEANUP_DEADLINE_MS = 10_000;
+const SAFE_ERROR_CODE = /^[A-Z][A-Z0-9_]{0,63}$/;
+
+function projectedErrorCode(error) {
+  if (!error) return null;
+  return typeof error.code === "string" && SAFE_ERROR_CODE.test(error.code)
+    ? error.code
+    : "CC_CLEANUP_STEP_FAILED";
+}
+
+export function normalizeCleanupDeadlineMs(value) {
+  return Number.isFinite(value) &&
+    value > 0 &&
+    value <= HOST_CLEANUP_DEADLINE_MS
+    ? Math.max(1, Math.floor(value))
+    : HOST_CLEANUP_DEADLINE_MS;
+}
+
+export function cleanupDeadlineError(report) {
+  const error = new Error(
+    `CLI cleanup exceeded the host deadline of ${report.timeoutMs} ms`,
+  );
+  error.code = "CC_CLEANUP_DEADLINE_EXCEEDED";
+  error.isCleanupDeadlineFailure = true;
+  error.timeoutMs = report.timeoutMs;
+  error.timedOutSteps = report.steps
+    .filter((step) => step.status === "timeout")
+    .map((step) => step.name);
+  error.cleanupReport = report;
+  return error;
+}
+
+/**
+ * One host-owned absolute deadline shared by a cleanup sequence. Operations
+ * are invoked in order. If an operation consumes the remaining budget, later
+ * disposers are still invoked (and observed) but are not awaited, so one
+ * uncooperative adapter cannot prevent exhaustive teardown from starting.
+ */
+export function createCleanupDeadline(
+  { timeoutMs, label = "cli-cleanup" } = {},
+  deps = {},
+) {
+  // A wall-clock adjustment must never extend teardown past the host ceiling.
+  const now = deps.now || (() => performance.now());
+  const setTimer = deps.setTimeout || setTimeout;
+  const clearTimer = deps.clearTimeout || clearTimeout;
+  const normalizedTimeoutMs = normalizeCleanupDeadlineMs(timeoutMs);
+  let startedAt = null;
+  let deadlineAt = null;
+  let exhausted = false;
+  const steps = [];
+
+  const ensureStarted = () => {
+    if (startedAt !== null) return;
+    startedAt = now();
+    deadlineAt = startedAt + normalizedTimeoutMs;
+  };
+
+  const record = (name, status, stepStartedAt, error = null) => {
+    steps.push(
+      Object.freeze({
+        name,
+        status,
+        durationMs: Math.max(0, now() - stepStartedAt),
+        errorCode: projectedErrorCode(error),
+      }),
+    );
+  };
+
+  return {
+    async run(name, operation) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new TypeError("cleanup step name is required");
+      }
+      if (typeof operation !== "function") {
+        record(name, "skipped", now());
+        return { status: "skipped" };
+      }
+      ensureStarted();
+      const stepStartedAt = now();
+      let promise;
+      try {
+        promise = Promise.resolve(operation());
+      } catch (error) {
+        record(name, "error", stepStartedAt, error);
+        return { status: "error", error };
+      }
+      // Always observe a late rejection after a timeout.
+      promise.catch(() => {});
+      const remainingMs = Math.max(0, deadlineAt - now());
+      if (exhausted || remainingMs === 0) {
+        exhausted = true;
+        record(name, "timeout", stepStartedAt);
+        return { status: "timeout" };
+      }
+
+      let timer = null;
+      const timeout = new Promise((resolve) => {
+        timer = setTimer(() => resolve({ timeout: true }), remainingMs);
+      });
+      const settled = await Promise.race([
+        promise.then(
+          (value) => ({ value }),
+          (error) => ({ error }),
+        ),
+        timeout,
+      ]);
+      if (timer !== null) clearTimer(timer);
+      if (settled?.timeout) {
+        // A platform timer can fire fractionally before performance.now()
+        // reaches deadlineAt. Latch exhaustion so later disposers are still
+        // invoked but never regain a sliver of cleanup budget.
+        exhausted = true;
+        record(name, "timeout", stepStartedAt);
+        return { status: "timeout" };
+      }
+      if (settled?.error) {
+        record(name, "error", stepStartedAt, settled.error);
+        return { status: "error", error: settled.error };
+      }
+      record(name, "completed", stepStartedAt);
+      return { status: "completed", value: settled.value };
+    },
+    report() {
+      const finishedAt = now();
+      const timedOut = steps.some((step) => step.status === "timeout");
+      return Object.freeze({
+        label,
+        timeoutMs: normalizedTimeoutMs,
+        startedAt,
+        finishedAt,
+        elapsedMs: startedAt === null ? 0 : Math.max(0, finishedAt - startedAt),
+        timedOut,
+        completed: !timedOut,
+        steps: Object.freeze([...steps]),
+      });
+    },
+  };
+}
+
+export const MAX_CLI_CLEANUP_DEADLINE_MS = HOST_CLEANUP_DEADLINE_MS;