chainlesschain 0.45.70 → 0.45.75

package/src/lib/skill-mcp.js

@@ -0,0 +1,190 @@
+/**
+ * Skill-Embedded MCP — skills declare their MCP servers inline (v5.0.2.9)
+ *
+ * Inspired by oh-my-openagent's "Skill-Embedded MCPs" design: instead of
+ * forcing users to pre-register MCP servers in a DB, a skill can declare
+ * the MCP servers it needs directly in its SKILL.md body. When the skill
+ * is activated, its servers are mounted; when the skill exits, they are
+ * unmounted. This keeps the agent's tool list scoped and avoids tool
+ * explosion across 130+ skills.
+ *
+ * Declaration format — a fenced code block tagged `mcp-servers` in the
+ * SKILL.md body (NOT frontmatter, so no YAML parser changes are needed):
+ *
+ *   ```mcp-servers
+ *   [
+ *     {
+ *       "name": "weather",
+ *       "command": "npx",
+ *       "args": ["-y", "@modelcontextprotocol/server-weather"]
+ *     }
+ *   ]
+ *   ```
+ *
+ * The block content must be a JSON array of server configs. Each config
+ * requires `name` and `command`; `args`, `env`, and `cwd` are optional.
+ *
+ * Pure functions only (except mount/unmount which take an MCPClient dep).
+ */
+
+/**
+ * Parse MCP server declarations from a SKILL.md body.
+ * Returns an empty array if no `mcp-servers` code block is present.
+ *
+ * @param {string} body - The markdown body after YAML frontmatter
+ * @returns {Array<object>} Array of validated server configs (may be empty)
+ */
+export function parseSkillMcpServers(body) {
+  if (typeof body !== "string" || body.length === 0) return [];
+
+  // Match fenced code blocks with info string "mcp-servers" or
+  // "json mcp-servers". We accept both because some users default to
+  // json-tagged blocks for editor highlighting.
+  const fenceRegex = /```(?:json\s+)?mcp-servers\s*\n([\s\S]*?)\n```/i;
+  const match = body.match(fenceRegex);
+  if (!match) return [];
+
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1]);
+  } catch {
+    // Malformed JSON — return empty, let caller decide whether to warn
+    return [];
+  }
+
+  if (!Array.isArray(parsed)) return [];
+
+  const validated = [];
+  for (const entry of parsed) {
+    const normalized = validateMcpServerConfig(entry);
+    if (normalized) validated.push(normalized);
+  }
+  return validated;
+}
+
+/**
+ * Validate a single server config. Returns a normalized frozen object on
+ * success, or null on validation failure.
+ *
+ * @param {object} entry
+ * @returns {object | null}
+ */
+export function validateMcpServerConfig(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  if (typeof entry.name !== "string" || entry.name.trim().length === 0) {
+    return null;
+  }
+  if (typeof entry.command !== "string" || entry.command.trim().length === 0) {
+    return null;
+  }
+
+  const normalized = {
+    name: entry.name.trim(),
+    command: entry.command.trim(),
+    args: Array.isArray(entry.args)
+      ? entry.args.filter((a) => typeof a === "string")
+      : [],
+  };
+  if (entry.env && typeof entry.env === "object" && !Array.isArray(entry.env)) {
+    normalized.env = { ...entry.env };
+  }
+  if (typeof entry.cwd === "string" && entry.cwd.length > 0) {
+    normalized.cwd = entry.cwd;
+  }
+  return Object.freeze(normalized);
+}
+
+/**
+ * Mount a skill's declared MCP servers on an existing MCPClient.
+ * Servers that fail to connect are skipped (errors collected in the
+ * result). Returns a handle that can be passed to unmountSkillMcpServers.
+ *
+ * @param {object} mcpClient - An instance of MCPClient (must expose .connect)
+ * @param {object} skill - Skill metadata with `mcpServers` array
+ * @param {object} [opts]
+ * @param {(msg: string, err?: Error) => void} [opts.onWarn] - Warning hook
+ * @returns {Promise<{ mounted: string[], skipped: Array<{ name: string, error: string }> }>}
+ */
+export async function mountSkillMcpServers(mcpClient, skill, opts = {}) {
+  const declared = Array.isArray(skill?.mcpServers) ? skill.mcpServers : [];
+  const mounted = [];
+  const skipped = [];
+
+  if (declared.length === 0) return { mounted, skipped };
+  if (!mcpClient || typeof mcpClient.connect !== "function") {
+    throw new Error("mountSkillMcpServers requires an MCPClient with .connect");
+  }
+
+  for (const server of declared) {
+    const normalized = validateMcpServerConfig(server);
+    if (!normalized) {
+      skipped.push({
+        name: server?.name || "(invalid)",
+        error: "invalid config",
+      });
+      continue;
+    }
+    try {
+      await mcpClient.connect(normalized.name, normalized);
+      mounted.push(normalized.name);
+    } catch (err) {
+      const message = err?.message || String(err);
+      skipped.push({ name: normalized.name, error: message });
+      if (typeof opts.onWarn === "function") {
+        opts.onWarn(
+          `[skill-mcp] Failed to mount "${normalized.name}" for skill "${skill?.id || skill?.name}": ${message}`,
+          err,
+        );
+      }
+    }
+  }
+
+  return { mounted, skipped };
+}
+
+/**
+ * Unmount previously-mounted skill MCP servers. Safe to call with an
+ * empty list or a handle from a failed mount.
+ *
+ * @param {object} mcpClient - An instance of MCPClient (must expose .disconnect)
+ * @param {string[]} mountedNames - Server names to unmount
+ * @returns {Promise<{ unmounted: string[], errors: Array<{ name: string, error: string }> }>}
+ */
+export async function unmountSkillMcpServers(mcpClient, mountedNames) {
+  const names = Array.isArray(mountedNames) ? mountedNames : [];
+  const unmounted = [];
+  const errors = [];
+
+  if (names.length === 0) return { unmounted, errors };
+  if (!mcpClient || typeof mcpClient.disconnect !== "function") {
+    // Fall back to disconnectAll if present — still not a hard failure
+    if (typeof mcpClient?.disconnectAll === "function") {
+      try {
+        await mcpClient.disconnectAll();
+        return { unmounted: names.slice(), errors };
+      } catch (err) {
+        return {
+          unmounted,
+          errors: names.map((name) => ({
+            name,
+            error: err?.message || String(err),
+          })),
+        };
+      }
+    }
+    throw new Error(
+      "unmountSkillMcpServers requires an MCPClient with .disconnect or .disconnectAll",
+    );
+  }
+
+  for (const name of names) {
+    try {
+      await mcpClient.disconnect(name);
+      unmounted.push(name);
+    } catch (err) {
+      errors.push({ name, error: err?.message || String(err) });
+    }
+  }
+
+  return { unmounted, errors };
+}

package/src/lib/workflow-state-reader.js

@@ -0,0 +1,94 @@
+/**
+ * CLI-side read-only reader for Coding Agent workflow state.
+ *
+ * Mirrors the file layout written by
+ * `desktop-app-vue/src/main/ai-engine/code-agent/session-state-manager.js`
+ * but is intentionally read-only — mutation happens in the desktop main
+ * process or via the workflow skills. The CLI's job is to let users
+ * inspect what the agent has persisted.
+ *
+ * Layout:
+ *   <projectRoot>/.chainlesschain/sessions/<sessionId>/
+ *     ├── intent.md
+ *     ├── plan.md     (YAML frontmatter: approved, updated, session)
+ *     ├── progress.log
+ *     └── mode.json
+ */
+
+import fs from "fs";
+import path from "path";
+
+function safeId(id) {
+  if (!id || typeof id !== "string" || !/^[A-Za-z0-9._-]+$/.test(id)) {
+    throw new Error(`Invalid sessionId: "${id}"`);
+  }
+  return id;
+}
+
+function sessionsRoot(projectRoot) {
+  return path.join(projectRoot, ".chainlesschain", "sessions");
+}
+
+export function listWorkflowSessions(projectRoot) {
+  const root = sessionsRoot(projectRoot);
+  if (!fs.existsSync(root)) {
+    return [];
+  }
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => {
+      const dir = path.join(root, e.name);
+      const mode = readMode(dir);
+      return {
+        sessionId: e.name,
+        stage: mode?.stage || null,
+        updatedAt: mode?.updatedAt || null,
+        hasIntent: fs.existsSync(path.join(dir, "intent.md")),
+        hasPlan: fs.existsSync(path.join(dir, "plan.md")),
+        approved: readPlanApproved(dir),
+      };
+    })
+    .sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+}
+
+function readMode(dir) {
+  const file = path.join(dir, "mode.json");
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function readPlanApproved(dir) {
+  const file = path.join(dir, "plan.md");
+  if (!fs.existsSync(file)) return null;
+  const raw = fs.readFileSync(file, "utf-8");
+  const fm = raw.match(/^---\n([\s\S]*?)\n---\n/);
+  if (!fm) return false;
+  return /approved:\s*true/.test(fm[1]);
+}
+
+export function readWorkflowSession(projectRoot, sessionId) {
+  safeId(sessionId);
+  const dir = path.join(sessionsRoot(projectRoot), sessionId);
+  if (!fs.existsSync(dir)) {
+    return null;
+  }
+  const intentFile = path.join(dir, "intent.md");
+  const planFile = path.join(dir, "plan.md");
+  const logFile = path.join(dir, "progress.log");
+  return {
+    sessionId,
+    dir,
+    mode: readMode(dir),
+    intent: fs.existsSync(intentFile)
+      ? fs.readFileSync(intentFile, "utf-8")
+      : null,
+    plan: fs.existsSync(planFile) ? fs.readFileSync(planFile, "utf-8") : null,
+    planApproved: readPlanApproved(dir),
+    progress: fs.existsSync(logFile) ? fs.readFileSync(logFile, "utf-8") : "",
+  };
+}