chainlesschain 0.162.36 → 0.162.38

package/src/commands/mcp.js

@@ -38,6 +38,49 @@ function getClient() {
   return mcpClient;
 }
 
+/**
+ * Connect MCP server(s) for a one-shot query (resources / prompts). Connects
+ * the named server, or every registered server when `serverName` is omitted.
+ * Returns `{ client, connected }`; the caller must `await shutdown()`.
+ */
+async function connectForQuery(program, serverName) {
+  const ctx = await bootstrap({ verbose: program.opts().verbose });
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  const config = new MCPServerConfig(db);
+  let rows;
+  if (serverName) {
+    const row = config.get(serverName);
+    if (!row) {
+      logger.error(
+        `Server "${serverName}" not configured. Use 'mcp add' first.`,
+      );
+      await shutdown();
+      process.exit(1);
+    }
+    rows = [row];
+  } else {
+    rows = config.list();
+  }
+  const client = new MCPClient();
+  const connected = [];
+  for (const row of rows) {
+    if (!row) continue;
+    try {
+      await client.connect(row.name, row);
+      connected.push(row.name);
+    } catch (err) {
+      logger.log(
+        chalk.yellow(`  Failed to connect "${row.name}": ${err.message}`),
+      );
+    }
+  }
+  return { client, connected };
+}
+
 // Phase 3 (Hosted MCP Policy): resolve runtime mode from --mode > env > local.
 function resolveMode(options) {
   return (
@@ -68,10 +111,20 @@ export function registerMcpCommand(program) {
   // mcp login — OAuth 2.0 (Auth Code + PKCE) for a remote MCP server.
   mcp
     .command("login <url>")
-    .description("Authorize a remote MCP server via OAuth (opens a browser); stores the token")
+    .description(
+      "Authorize a remote MCP server via OAuth (opens a browser); stores the token",
+    )
     .option("--scope <scope>", "OAuth scope(s) to request")
-    .option("--client-id <id>", "Use a pre-registered client_id instead of dynamic registration")
-    .option("--port <n>", "Localhost callback port", (v) => parseInt(v, 10), 53682)
+    .option(
+      "--client-id <id>",
+      "Use a pre-registered client_id instead of dynamic registration",
+    )
+    .option(
+      "--port <n>",
+      "Localhost callback port",
+      (v) => parseInt(v, 10),
+      53682,
+    )
     .option("--no-open", "Print the authorize URL instead of opening a browser")
     .action(async (url, options) => {
       try {
@@ -109,7 +162,8 @@ export function registerMcpCommand(program) {
     .description("Delete the stored OAuth token for a remote MCP server")
     .action(async (url) => {
       try {
-        const { deleteStoredToken, serverKey } = await import("../lib/mcp-oauth.js");
+        const { deleteStoredToken, serverKey } =
+          await import("../lib/mcp-oauth.js");
         const ok = deleteStoredToken(url);
         logger.log(
           ok
@@ -129,7 +183,8 @@ export function registerMcpCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
-        const { loadTokenStore, isTokenExpired } = await import("../lib/mcp-oauth.js");
+        const { loadTokenStore, isTokenExpired } =
+          await import("../lib/mcp-oauth.js");
         const store = loadTokenStore();
         const rows = Object.values(store).map((r) => ({
           server: r.server,
@@ -142,7 +197,9 @@ export function registerMcpCommand(program) {
           return;
         }
         if (rows.length === 0) {
-          logger.log(chalk.gray("No MCP OAuth tokens. Run: cc mcp login <url>"));
+          logger.log(
+            chalk.gray("No MCP OAuth tokens. Run: cc mcp login <url>"),
+          );
           return;
         }
         for (const r of rows) {
@@ -566,6 +623,179 @@ export function registerMcpCommand(program) {
       }
     });
 
+  // mcp resources — list resources exposed by configured servers
+  mcp
+    .command("resources")
+    .description("List resources exposed by MCP servers")
+    .option("-s, --server <name>", "Filter by / connect only this server")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        const resources = client.listResources(options.server);
+        if (options.json) {
+          console.log(JSON.stringify(resources, null, 2));
+        } else if (resources.length === 0) {
+          logger.info("No resources available.");
+        } else {
+          logger.log(chalk.bold(`MCP Resources (${resources.length}):\n`));
+          for (const r of resources) {
+            logger.log(`  ${chalk.cyan(r.uri)} ${chalk.gray(`[${r.server}]`)}`);
+            if (r.name) logger.log(`    ${chalk.gray(r.name)}`);
+            if (r.description) logger.log(`    ${chalk.gray(r.description)}`);
+          }
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp read-resource — read a resource's contents by URI
+  mcp
+    .command("read-resource")
+    .description("Read an MCP resource by URI")
+    .argument("<uri>", "Resource URI")
+    .option("-s, --server <name>", "Server that owns the resource")
+    .option("--json", "Output as JSON")
+    .action(async (uri, options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        let server = options.server;
+        if (!server) {
+          const match = client.listResources().find((r) => r.uri === uri);
+          if (!match) {
+            logger.error(
+              `Resource "${uri}" not found. Run 'mcp resources' to list URIs.`,
+            );
+            await client.disconnectAll();
+            await shutdown();
+            process.exit(1);
+          }
+          server = match.server;
+        }
+        const result = await client.readResource(server, uri);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (Array.isArray(result?.contents)) {
+          for (const c of result.contents) {
+            if (typeof c.text === "string") {
+              logger.log(c.text);
+            } else if (c.blob) {
+              logger.log(
+                chalk.gray(
+                  `[Binary: ${c.mimeType || "application/octet-stream"}]`,
+                ),
+              );
+            } else {
+              logger.log(JSON.stringify(c, null, 2));
+            }
+          }
+        } else {
+          logger.log(JSON.stringify(result, null, 2));
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Read failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp prompts — list prompts (server-provided slash commands)
+  mcp
+    .command("prompts")
+    .description("List prompts exposed by MCP servers")
+    .option("-s, --server <name>", "Filter by / connect only this server")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        const prompts = client.listPrompts(options.server);
+        if (options.json) {
+          console.log(JSON.stringify(prompts, null, 2));
+        } else if (prompts.length === 0) {
+          logger.info("No prompts available.");
+        } else {
+          logger.log(chalk.bold(`MCP Prompts (${prompts.length}):\n`));
+          for (const p of prompts) {
+            logger.log(
+              `  ${chalk.cyan(`/mcp__${p.server}__${p.name}`)} ${chalk.gray(`[${p.server}]`)}`,
+            );
+            if (p.description) logger.log(`    ${chalk.gray(p.description)}`);
+            if (Array.isArray(p.arguments) && p.arguments.length > 0) {
+              const argNames = p.arguments
+                .map((a) => (a.required ? `${a.name}*` : a.name))
+                .join(", ");
+              logger.log(`    ${chalk.gray(`args: ${argNames}`)}`);
+            }
+          }
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mcp get-prompt — fetch a rendered prompt by name
+  mcp
+    .command("get-prompt")
+    .description("Fetch a rendered MCP prompt by name")
+    .argument("<name>", "Prompt name")
+    .option("-s, --server <name>", "Server that owns the prompt")
+    .option("-a, --args <json>", "Prompt arguments as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const { client } = await connectForQuery(program, options.server);
+        let server = options.server;
+        if (!server) {
+          const match = client.listPrompts().find((p) => p.name === name);
+          if (!match) {
+            logger.error(
+              `Prompt "${name}" not found. Run 'mcp prompts' to list prompts.`,
+            );
+            await client.disconnectAll();
+            await shutdown();
+            process.exit(1);
+          }
+          server = match.server;
+        }
+        const args = options.args ? JSON.parse(options.args) : {};
+        const result = await client.getPrompt(server, name, args);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          if (result?.description) {
+            logger.log(chalk.gray(result.description) + "\n");
+          }
+          for (const msg of result?.messages || []) {
+            const blocks = Array.isArray(msg.content)
+              ? msg.content
+              : [msg.content];
+            for (const b of blocks) {
+              if (b && b.type === "text") {
+                logger.log(`${chalk.gray(`[${msg.role}]`)} ${b.text}`);
+              } else {
+                logger.log(
+                  `${chalk.gray(`[${msg.role}]`)} ${JSON.stringify(b)}`,
+                );
+              }
+            }
+          }
+        }
+        await client.disconnectAll();
+        await shutdown();
+      } catch (err) {
+        logger.error(`Get prompt failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // mcp scaffold — generate a boilerplate MCP server project
   mcp
     .command("scaffold <name>")

package/src/harness/mcp-client.js

@@ -156,7 +156,7 @@ export class MCPClient extends EventEmitter {
       // Initialize MCP protocol
       const initResult = await this._sendRequest(name, "initialize", {
         protocolVersion: "2024-11-05",
-        capabilities: { tools: {}, resources: {} },
+        capabilities: { tools: {}, resources: {}, prompts: {} },
         clientInfo: { name: "chainlesschain-cli", version: "0.37.9" },
       });
 
@@ -187,12 +187,21 @@ export class MCPClient extends EventEmitter {
         // Server may not support resources
       }
 
+      // Fetch available prompts (server-provided slash commands)
+      try {
+        const promptsResult = await this._sendRequest(name, "prompts/list", {});
+        entry.prompts = promptsResult?.prompts || [];
+      } catch {
+        // Server may not support prompts
+      }
+
       this.emit("server-connected", { name, tools: entry.tools.length });
       return {
         name,
         state: entry.state,
         tools: entry.tools,
         resources: entry.resources,
+        prompts: entry.prompts,
         serverInfo: entry.serverInfo,
       };
     } catch (err) {
@@ -250,6 +259,7 @@ export class MCPClient extends EventEmitter {
         state: entry.state,
         tools: entry.tools.length,
         resources: entry.resources.length,
+        prompts: (entry.prompts || []).length,
         serverInfo: entry.serverInfo || {},
       });
     }
@@ -296,6 +306,26 @@ export class MCPClient extends EventEmitter {
     return result;
   }
 
+  /**
+   * List resources from a specific server or all servers. Each resource is
+   * annotated with its owning `server` (mirrors `listTools`).
+   */
+  listResources(serverName) {
+    if (serverName) {
+      const entry = this.servers.get(serverName);
+      if (!entry) throw new Error(`Server "${serverName}" not found`);
+      return (entry.resources || []).map((r) => ({ ...r, server: serverName }));
+    }
+
+    const all = [];
+    for (const [name, entry] of this.servers) {
+      for (const r of entry.resources || []) {
+        all.push({ ...r, server: name });
+      }
+    }
+    return all;
+  }
+
   /**
    * Read a resource from a server.
    */
@@ -309,6 +339,45 @@ export class MCPClient extends EventEmitter {
     return result;
   }
 
+  /**
+   * List prompts from a specific server or all servers. Each prompt is
+   * annotated with its owning `server` (mirrors `listTools`).
+   */
+  listPrompts(serverName) {
+    if (serverName) {
+      const entry = this.servers.get(serverName);
+      if (!entry) throw new Error(`Server "${serverName}" not found`);
+      return (entry.prompts || []).map((p) => ({ ...p, server: serverName }));
+    }
+
+    const all = [];
+    for (const [name, entry] of this.servers) {
+      for (const p of entry.prompts || []) {
+        all.push({ ...p, server: name });
+      }
+    }
+    return all;
+  }
+
+  /**
+   * Fetch a rendered prompt (`prompts/get`) from a server. `args` is a map of
+   * the prompt's named arguments to string values. Returns the server's result
+   * `{ description?, messages: [...] }`.
+   */
+  async getPrompt(serverName, promptName, args = {}) {
+    const entry = this.servers.get(serverName);
+    if (!entry) throw new Error(`Server "${serverName}" not found`);
+    if (entry.state !== ServerState.CONNECTED) {
+      throw new Error(`Server "${serverName}" is not connected`);
+    }
+
+    const result = await this._sendRequest(serverName, "prompts/get", {
+      name: promptName,
+      arguments: args || {},
+    });
+    return result;
+  }
+
   // ─── Internal JSON-RPC transport ──────────────────────────────
 
   _sendRequest(serverName, method, params) {

package/src/index.js

@@ -62,6 +62,7 @@ import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerGoalCommand } from "./commands/goal.js";
 import { registerCommandCommand } from "./commands/command.js";
 import { registerCompactCommand } from "./commands/compact.js";
+import { registerLoopCommand } from "./commands/loop.js";
 import { registerPermissionsCommand } from "./commands/permissions.js";
 import { registerOutputStyleCommand } from "./commands/output-style.js";
 import { registerStatuslineCommand } from "./commands/statusline.js";
@@ -464,6 +465,7 @@ export function createProgram(opts = {}) {
   registerGoalCommand(program);
   registerCommandCommand(program);
   registerCompactCommand(program);
+  registerLoopCommand(program);
   registerPermissionsCommand(program);
   registerOutputStyleCommand(program);
   registerStatuslineCommand(program);

package/src/lib/loop.js

@@ -0,0 +1,198 @@
+/**
+ * cc loop — core driver (pure, dependency-injected) for the fixed-interval
+ * loop runner. The command layer (src/commands/loop.js) supplies a concrete
+ * `runIteration` (spawns a child process) plus a real clock; everything here
+ * is side-effect-free and clock-injected so the loop semantics — iteration
+ * counting, stop conditions, between-run delay — are deterministically
+ * testable without timers or subprocesses.
+ *
+ * Claude-Code `/loop` parity (fixed-interval MVP): run a command or agent
+ * prompt repeatedly until a stop condition fires (max iterations / exit 0 /
+ * output match) or the caller aborts (Ctrl-C).
+ */
+
+/** Multipliers for the duration suffixes we accept. */
+const DURATION_UNITS = { ms: 1, s: 1000, m: 60000, h: 3600000 };
+
+/**
+ * Parse a human interval ("30s", "5m", "1.5h", "500ms") into milliseconds.
+ * A bare number is interpreted as SECONDS (the natural unit for an interval),
+ * so `--every 30` === `--every 30s`. Throws on anything unparseable.
+ */
+export function parseDuration(input) {
+  if (typeof input === "number" && Number.isFinite(input)) {
+    return Math.max(0, Math.round(input));
+  }
+  const s = String(input ?? "")
+    .trim()
+    .toLowerCase();
+  const m = s.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/);
+  if (!m) {
+    throw new Error(
+      `invalid duration: "${input}" (use 30s, 5m, 1.5h, or 500ms)`,
+    );
+  }
+  const value = parseFloat(m[1]);
+  const unit = m[2] || "s"; // bare number → seconds
+  return Math.round(value * DURATION_UNITS[unit]);
+}
+
+/** Render a millisecond duration back to a compact human string. */
+export function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${trim(ms / 1000)}s`;
+  if (ms < 3600000) return `${trim(ms / 60000)}m`;
+  return `${trim(ms / 3600000)}h`;
+}
+
+function trim(n) {
+  // Strip trailing ".0" so 5.0 → "5" but 1.5 stays "1.5".
+  return Number.isInteger(n) ? String(n) : n.toFixed(2).replace(/\.?0+$/, "");
+}
+
+/**
+ * Parse the `--dynamic` control directives an iteration may print so it can
+ * self-pace. An iteration ends its output with at most one of:
+ *   [[loop:next <interval>]]   schedule the next run after <interval>
+ *   [[loop:stop]]              the task is done; stop looping
+ * Returns { done, nextDelayMs }. `stop` wins over `next` (done short-circuits
+ * before the next sleep). A malformed interval is ignored (falls back to the
+ * fixed `--every`). Lives here so the protocol is unit-testable in isolation.
+ */
+export function parseLoopDirectives(output) {
+  const text = String(output || "");
+  const result = { done: false, nextDelayMs: null };
+  if (/\[\[\s*loop:stop\s*\]\]/i.test(text)) result.done = true;
+  const m = text.match(/\[\[\s*loop:next\s+([0-9.]+\s*(?:ms|s|m|h)?)\s*\]\]/i);
+  if (m) {
+    try {
+      result.nextDelayMs = parseDuration(m[1]);
+    } catch {
+      /* malformed interval → leave null, caller falls back to --every */
+    }
+  }
+  return result;
+}
+
+/**
+ * Reduce a persisted loop session's events into the state needed to resume it:
+ * the original `loop_config`, how many iterations already completed, and the
+ * last recorded exit code. Pure (operates on the event array, no fs) so the
+ * resume reconstruction is unit-testable without the session store.
+ */
+export function summarizeLoopEvents(events) {
+  let config = null;
+  let completedIterations = 0;
+  let lastExitCode = null;
+  for (const e of events || []) {
+    if (e?.type === "loop_config") {
+      config = e.data || null;
+    } else if (e?.type === "loop_iteration") {
+      completedIterations += 1;
+      if (e.data && typeof e.data.exitCode !== "undefined") {
+        lastExitCode = e.data.exitCode;
+      }
+    }
+  }
+  return { config, completedIterations, lastExitCode };
+}
+
+/** Default abortable sleep — resolves early if the signal aborts. */
+export function makeSleep(signal) {
+  return (ms) =>
+    new Promise((resolve) => {
+      if (signal?.aborted || ms <= 0) return resolve();
+      // NB: do NOT unref() — the pending interval timer is what keeps the
+      // process alive between rounds. Under a TTY the active stdin would mask
+      // an unref'd timer, but headless (piped stdin / CI / cron) the loop would
+      // exit after the first round. SIGINT aborts the wait via the signal.
+      const t = setTimeout(resolve, ms);
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve();
+        },
+        { once: true },
+      );
+    });
+}
+
+/**
+ * Drive the loop. Calls `runIteration(n)` once per round (1-based), evaluates
+ * the stop conditions AFTER each round, and sleeps `intervalMs` between rounds
+ * (never after the final round). Returns a summary describing why it stopped.
+ *
+ * @param {object}   opts
+ * @param {(n:number)=>Promise<{exitCode?:number, output?:string}>} opts.runIteration
+ * @param {number}   opts.intervalMs       default delay between iterations (>= 0)
+ * @param {number}  [opts.maxIterations]   stop after N rounds (>= 1)
+ * @param {boolean} [opts.untilExitZero]   stop once a round exits with code 0
+ * @param {RegExp}  [opts.untilRegex]      stop once a round's output matches
+ * @param {(ms:number)=>Promise<void>} [opts.sleep]  injectable delay
+ * @param {()=>boolean} [opts.shouldStop]  external stop probe (e.g. SIGINT)
+ * @param {(n:number, res:object)=>void} [opts.onIteration] per-round hook
+ * @param {number}  [opts.startIndex]      iterations already done (resume)
+ * @returns {Promise<{iterations:number, stoppedBy:string, results:object[]}>}
+ *          `iterations` is cumulative (startIndex + rounds run this call);
+ *          `results` holds only this call's rounds.
+ */
+export async function runLoop({
+  runIteration,
+  intervalMs,
+  maxIterations,
+  untilExitZero = false,
+  untilRegex = null,
+  sleep,
+  shouldStop,
+  onIteration,
+  startIndex = 0,
+}) {
+  if (typeof runIteration !== "function") {
+    throw new Error("runLoop requires a runIteration function");
+  }
+  const delay = sleep || makeSleep();
+  const results = [];
+  // Iterations already completed in a prior (resumed) run. `i` continues from
+  // here so the displayed/persisted round numbers are cumulative and
+  // `maxIterations` counts across resume.
+  let i = startIndex;
+
+  while (true) {
+    if (shouldStop && shouldStop()) {
+      return { iterations: i, stoppedBy: "signal", results };
+    }
+
+    i += 1;
+    const res = (await runIteration(i)) || {};
+    results.push(res);
+    if (onIteration) onIteration(i, res);
+
+    // Stop conditions, most-specific first. Evaluated after the round so the
+    // work always runs at least once before any condition can end the loop.
+    // `res.done` is the iteration's own explicit stop (e.g. a --dynamic
+    // [[loop:stop]] directive) and wins over everything else.
+    if (res.done) {
+      return { iterations: i, stoppedBy: "done", results };
+    }
+    if (untilExitZero && res.exitCode === 0) {
+      return { iterations: i, stoppedBy: "exit-zero", results };
+    }
+    if (untilRegex && untilRegex.test(res.output || "")) {
+      return { iterations: i, stoppedBy: "match", results };
+    }
+    if (maxIterations && i >= maxIterations) {
+      return { iterations: i, stoppedBy: "max-iterations", results };
+    }
+    if (shouldStop && shouldStop()) {
+      return { iterations: i, stoppedBy: "signal", results };
+    }
+
+    // An iteration may set its own next interval (--dynamic [[loop:next]]);
+    // otherwise fall back to the fixed --every delay.
+    const nextMs = Number.isFinite(res.nextDelayMs)
+      ? res.nextDelayMs
+      : intervalMs;
+    await delay(nextMs);
+  }
+}

package/src/lib/settings-hooks.cjs

@@ -37,6 +37,7 @@ const HOOK_EVENTS = Object.freeze([
   "PostToolUse",
   "UserPromptSubmit",
   "Stop",
+  "SubagentStop",
   "SessionStart",
   "SessionEnd",
   "PreCompact",