@skaile/workspaces 0.24.0 → 0.25.0

package/dist/{chunk-JQBHCJ6N.js → chunk-BJWUSHC4.js}

@@ -1,4 +1,4 @@
-import { WorkspacePlugin } from './chunk-J2TITSXF.js';
+import { WorkspacePlugin } from './chunk-4QVFQEY2.js';
 import { WebSocketServerTransport } from './chunk-WQ7DE5UC.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { PROTOCOL_VERSION } from './chunk-TDSRLMDB.js';
@@ -6,13 +6,14 @@ import { EventNormalizer } from './chunk-M5TE6YI5.js';
 import { classifyClaudeSdkError } from './chunk-DQWREFRQ.js';
 import { createDriver } from './chunk-6VTG73UY.js';
 import { deployCatalogEntry, undeployCatalogEntry } from './chunk-LV2HPH3C.js';
-import { registerBuiltinConnectors, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildConnectorPromptSection, buildSdkConnectorTools } from './chunk-HIIARTRZ.js';
-import { loadConnectorDeclarations, PreMintedSecretProvider, InMemorySecretProvider } from './chunk-ODPII24X.js';
+import { registerBuiltinConnectors, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildConnectorPromptSection, buildSdkConnectorTools } from './chunk-XMP6XTMF.js';
+import { loadConnectorDeclarations, PreMintedSecretProvider, InMemorySecretProvider } from './chunk-SETTLPBD.js';
 import { renderStimulusPrompt, buildOrchestratorPrompt } from './chunk-GZWJGNNN.js';
-import { resolveSettings, resolveApiKey, providerEnvKey } from './chunk-Z3M5K67G.js';
-import { resolveRuntimeAssets } from './chunk-5ESCS2OS.js';
-import { loadMcpServerDeclarations, resolveSkWorkspaceConfig, resolveAgentDir, validateAssetRecipeAttr, COMPACTION_DEFAULTS } from './chunk-542K7SR6.js';
-import { parseAssetRef } from './chunk-YX3UWPJ5.js';
+import { resolveSettings, resolveApiKey, providerEnvKey } from './chunk-XVL22AWE.js';
+import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
+import { resolveRuntimeAssets } from './chunk-UD4ZLXGS.js';
+import { resolveSkWorkspaceConfig, resolveAgentDir, stageMaterializedSkills, loadMcpServerDeclarations, COMPACTION_DEFAULTS, validateAssetRecipeAttr } from './chunk-3QTZWPGH.js';
+import { parseAssetRef } from './chunk-WIAHJOMG.js';
 import { getLogStore, resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, registerLogStore, resetLogStore, createLogger } from './chunk-24UIWON4.js';
 import { __require } from './chunk-NSBPE2FW.js';
 import pc from 'picocolors';
@@ -28,6 +29,10 @@ import { createHash, randomUUID } from 'crypto';
 import { execFile, spawnSync } from 'child_process';
 import { promisify } from 'util';
 import { parse } from 'yaml';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import mime from 'mime';
 
 // runner/src/logging-bootstrap.ts
@@ -850,8 +855,262 @@ function validateSubstitutedPaths(command, args) {
   return missing;
 }
 
+// runner/src/external-mcp.ts
+function resolveRecordSecrets(record, secrets) {
+  if (!secrets) return record;
+  const resolved = {};
+  for (const [k, v] of Object.entries(record)) {
+    resolved[k] = secrets.resolve(v) ?? v;
+  }
+  return resolved;
+}
+var RESERVED_MCP_SERVER_IDS = /* @__PURE__ */ new Set([
+  "skaile-connectors",
+  "skaile-workspace",
+  "skaile-capabilities"
+]);
+function resolveExternalMcpDeclarations(projectDir, sessionId) {
+  const mcpLog = createLogger({
+    kind: "mcp",
+    subkind: "wiring",
+    instance: sessionId ?? "no-session"
+  });
+  const mcpDeclarations = loadMcpServerDeclarations(projectDir);
+  mcpLog.debug("loaded MCP declarations", { count: mcpDeclarations.length });
+  const recipeCache = createRecipeCache();
+  const nixFlakeRef = process.env.SKAILE_NIX_FLAKE_REF ?? "/etc/skaile/flake";
+  const resolved = [];
+  for (const decl of mcpDeclarations) {
+    if (RESERVED_MCP_SERVER_IDS.has(decl.id)) {
+      mcpLog.warn("MCP server skipped: reserved id", { id: decl.id });
+      continue;
+    }
+    let resolvedDecl = decl;
+    if (decl.recipe) {
+      const recipeLogKey = decl.recipe.flake ? { flake: decl.recipe.flake } : { attr: decl.recipe.attr };
+      try {
+        const recipeKey = decl.recipe.flake ? `mcps.${decl.id}` : decl.recipe.attr ?? `mcps.${decl.id}`;
+        const outPath = resolveRecipePath(nixFlakeRef, recipeKey, recipeCache);
+        const outPaths = /* @__PURE__ */ new Map([[decl.id, outPath]]);
+        const resolvedCommand = decl.command ? substituteRecipeTemplating(decl.command, outPaths) : decl.command;
+        const resolvedArgs = decl.args?.map((a) => substituteRecipeTemplating(a, outPaths));
+        const resolvedEnv = substituteRecipeMap(decl.env, outPaths);
+        resolvedDecl = {
+          ...decl,
+          command: resolvedCommand,
+          args: resolvedArgs,
+          env: resolvedEnv
+        };
+        const recipeLog = createLogger({
+          kind: "mcp",
+          subkind: decl.id,
+          instance: "recipe-resolve"
+        });
+        const allResolved = [
+          resolvedCommand ?? "",
+          ...resolvedArgs ?? [],
+          ...Object.values(resolvedEnv ?? {})
+        ];
+        for (const v of allResolved) {
+          if (v.includes("${recipe:")) {
+            recipeLog.warn("unresolved recipe marker after substitution", {
+              value: v,
+              declId: decl.id
+            });
+          }
+        }
+        const missingPaths = validateSubstitutedPaths(resolvedCommand, resolvedArgs);
+        if (missingPaths.length > 0) {
+          recipeLog.error("MCP server skipped: substituted path does not exist", void 0, {
+            id: decl.id,
+            ...recipeLogKey,
+            missing: missingPaths
+          });
+          continue;
+        }
+        recipeLog.info("recipe substitution complete", { ...recipeLogKey, outPath });
+      } catch (err) {
+        createLogger({ kind: "mcp", subkind: decl.id, instance: "recipe-resolve" }).error(
+          "MCP server skipped: recipe resolution failed",
+          err,
+          { id: decl.id, ...recipeLogKey, flakeRef: nixFlakeRef }
+        );
+        continue;
+      }
+    }
+    resolved.push(resolvedDecl);
+  }
+  return resolved;
+}
+var PASSTHROUGH_INPUT_ZOD = {
+  parse: (v) => v
+};
+function buildTransport(decl, secrets) {
+  const transport = decl.transport ?? "stdio";
+  if (transport === "stdio") {
+    if (!decl.command) {
+      throw new Error(`stdio MCP server '${decl.id}' is missing 'command'`);
+    }
+    const env = {
+      ...getDefaultEnvironment(),
+      ...resolveRecordSecrets(decl.env ?? {}, secrets)
+    };
+    return new StdioClientTransport({
+      command: decl.command,
+      args: decl.args ?? [],
+      env,
+      stderr: "pipe"
+    });
+  }
+  if (transport === "sse") {
+    if (!decl.url) throw new Error(`sse MCP server '${decl.id}' is missing 'url'`);
+    const headers = resolveRecordSecrets(decl.headers ?? {}, secrets);
+    return new SSEClientTransport(new URL(decl.url), { requestInit: { headers } });
+  }
+  if (transport === "http") {
+    if (!decl.url) throw new Error(`http MCP server '${decl.id}' is missing 'url'`);
+    const headers = resolveRecordSecrets(decl.headers ?? {}, secrets);
+    return new StreamableHTTPClientTransport(new URL(decl.url), { requestInit: { headers } });
+  }
+  throw new Error(`Unknown MCP transport '${transport}' for server '${decl.id}'`);
+}
+function defaultMcpClientConnector(secrets) {
+  return async (decl) => {
+    const transport = buildTransport(decl, secrets);
+    const client = new Client({ name: "skaile-runner", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(transport);
+    return client;
+  };
+}
+var ExternalMcpManager = class {
+  /**
+   * @param registry  Session capability registry to register MCP tools into.
+   * @param secrets   Secret provider for resolving `env:` / `forge:` refs in the
+   *                  stdio subprocess env and sse/http headers.
+   * @param sessionId Used for the logger instance slice.
+   * @param connect   Optional connector override (tests inject a fake client so
+   *                  no live subprocess is spawned). Defaults to the real SDK
+   *                  client + transport.
+   */
+  constructor(registry, secrets, sessionId, connect) {
+    this.registry = registry;
+    this.connect = connect ?? defaultMcpClientConnector(secrets);
+    this.log = createLogger({
+      kind: "mcp",
+      subkind: "runner-managed",
+      instance: sessionId ?? "no-session"
+    });
+  }
+  registry;
+  servers = [];
+  log;
+  connect;
+  /** True when at least one external server connected and registered tools. */
+  hasServers() {
+    return this.servers.length > 0;
+  }
+  /**
+   * Connect every declaration and register its tools. Per-server failures are
+   * logged and skipped so a single bad server never blocks the session.
+   */
+  async start(declarations) {
+    for (const decl of declarations) {
+      try {
+        await this.startServer(decl);
+      } catch (err) {
+        this.log.error("MCP server spawn failed; skipping", err, {
+          id: decl.id,
+          transport: decl.transport ?? "stdio"
+        });
+      }
+    }
+  }
+  async startServer(decl) {
+    const client = await this.connect(decl);
+    const toolNames = [];
+    try {
+      const { tools } = await client.listTools();
+      for (const tool of tools) {
+        const cap = this.buildToolCapability(decl.id, tool, client);
+        this.registry.register(cap, "agent");
+        toolNames.push(cap.name);
+      }
+    } catch (err) {
+      for (const name of toolNames) this.registry.deregister(name);
+      try {
+        await client.close();
+      } catch {
+      }
+      throw err;
+    }
+    this.servers.push({ id: decl.id, client, toolNames });
+    this.log.info("MCP server registered (runner-managed)", {
+      id: decl.id,
+      transport: decl.transport ?? "stdio",
+      toolCount: toolNames.length,
+      tools: toolNames
+    });
+  }
+  /**
+   * Wrap a single MCP tool as a {@link DefinedCapability}. The capability name
+   * is `mcp__<server>__<tool>` (the naming claude-sdk wildcards and prompts
+   * depend on). The handler proxies the call to the live MCP client; a tool
+   * error (`isError`) is rethrown so the capability dispatch path surfaces it
+   * to the LLM as a tool failure.
+   */
+  buildToolCapability(serverId, tool, client) {
+    const name = `mcp__${serverId}__${tool.name}`;
+    const inputSchema = tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : { type: "object" };
+    return {
+      name,
+      description: tool.description ?? `MCP tool ${tool.name} from server ${serverId}`,
+      inputSchema,
+      side: "agent",
+      origin: { kind: "mcp", serverId },
+      scope: "session",
+      kind: "effect",
+      // LLM-only — these are agent tools, not user command-palette actions.
+      audience: ["llm"],
+      inputZod: PASSTHROUGH_INPUT_ZOD,
+      handler: async (input, ctx) => {
+        const result = await client.callTool({
+          name: tool.name,
+          arguments: input ?? {}
+        });
+        const content = result.content ?? [];
+        const text = content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+        if (result.isError) {
+          throw new Error(text || `MCP tool ${name} returned an error`);
+        }
+        ctx.log.debug("mcp tool ok", { tool: name, hasText: text.length > 0 });
+        return text.length > 0 ? text : content;
+      }
+    };
+  }
+  /**
+   * Deregister every tool and close every client (kills the subprocesses).
+   * Best-effort: a failed close on one server does not prevent the rest.
+   */
+  async dispose() {
+    for (const server of this.servers) {
+      for (const toolName of server.toolNames) {
+        this.registry.deregister(toolName);
+      }
+      try {
+        await server.client.close();
+      } catch (err) {
+        this.log.warn("MCP server close failed", {
+          id: server.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    this.servers.length = 0;
+  }
+};
+
 // runner/src/resources.ts
-async function buildAgentResources(projectDir, driverType, _onLog, watch, secretProvider, sessionMeta, tokenMediator, preMintedSecrets, deferFilesystemMounts) {
+async function buildAgentResources(projectDir, driverType, _onLog, watch, secretProvider, sessionMeta, tokenMediator, preMintedSecrets, deferFilesystemMounts, capabilityRegistry) {
   const resLog = createLogger({
     kind: "runner",
     subkind: "resources",
@@ -920,13 +1179,9 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
       }
     }
     const resourcePromptSection = resourceManager ? buildConnectorPromptSection(resourceManager) : "";
-    const mcpLog = createLogger({
-      kind: "mcp",
-      subkind: "wiring",
-      instance: sessionMeta?.sessionId ?? "no-session"
-    });
     let mcpServers;
     let workspacePluginToShutdown = null;
+    let externalMcpManager = null;
     if (driverType === "claude-sdk") {
       if (resourceManager) {
         const connectorsLog = createLogger({ kind: "mcp", subkind: "skaile-connectors" });
@@ -957,96 +1212,34 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
         mcpServers = { ...mcpServers ?? {}, "skaile-workspace": wsServer };
       }
       workspacePluginToShutdown = workspacePlugin;
-      const mcpDeclarations = loadMcpServerDeclarations(projectDir);
-      mcpLog.debug("loaded MCP declarations", { count: mcpDeclarations.length });
-      const recipeCache = createRecipeCache();
-      const nixFlakeRef = process.env.SKAILE_NIX_FLAKE_REF ?? "/etc/skaile/flake";
-      for (const decl of mcpDeclarations) {
-        if (RESERVED_MCP_SERVER_IDS.has(decl.id)) {
-          mcpLog.warn("MCP server skipped: reserved id", { id: decl.id });
-          continue;
-        }
-        let resolvedDecl = decl;
-        if (decl.recipe) {
-          const recipeLogKey = decl.recipe.flake ? { flake: decl.recipe.flake } : { attr: decl.recipe.attr };
-          try {
-            const recipeKey = decl.recipe.flake ? `mcps.${decl.id}` : decl.recipe.attr ?? `mcps.${decl.id}`;
-            const outPath = resolveRecipePath(nixFlakeRef, recipeKey, recipeCache);
-            const outPaths = /* @__PURE__ */ new Map([[decl.id, outPath]]);
-            const resolvedCommand = decl.command ? substituteRecipeTemplating(decl.command, outPaths) : decl.command;
-            const resolvedArgs = decl.args?.map((a) => substituteRecipeTemplating(a, outPaths));
-            const resolvedEnv = substituteRecipeMap(decl.env, outPaths);
-            resolvedDecl = {
-              ...decl,
-              command: resolvedCommand,
-              args: resolvedArgs,
-              env: resolvedEnv
-            };
-            const allResolved = [
-              resolvedCommand ?? "",
-              ...resolvedArgs ?? [],
-              ...Object.values(resolvedEnv ?? {})
-            ];
-            for (const v of allResolved) {
-              if (v.includes("${recipe:")) {
-                const recipeLog2 = createLogger({
-                  kind: "mcp",
-                  subkind: decl.id,
-                  instance: "recipe-resolve"
-                });
-                recipeLog2.warn("unresolved recipe marker after substitution", {
-                  value: v,
-                  declId: decl.id
-                });
-              }
-            }
-            const missingPaths = validateSubstitutedPaths(resolvedCommand, resolvedArgs);
-            if (missingPaths.length > 0) {
-              const recipeLog2 = createLogger({
-                kind: "mcp",
-                subkind: decl.id,
-                instance: "recipe-resolve"
-              });
-              recipeLog2.error("MCP server skipped: substituted path does not exist", void 0, {
-                id: decl.id,
-                ...recipeLogKey,
-                missing: missingPaths
-              });
-              continue;
-            }
-            const recipeLog = createLogger({
-              kind: "mcp",
-              subkind: decl.id,
-              instance: "recipe-resolve"
-            });
-            recipeLog.info("recipe substitution complete", {
-              ...recipeLogKey,
-              outPath
-            });
-          } catch (err) {
-            const recipeLog = createLogger({
-              kind: "mcp",
-              subkind: decl.id,
-              instance: "recipe-resolve"
-            });
-            recipeLog.error("MCP server skipped: recipe resolution failed", err, {
-              id: decl.id,
-              ...recipeLogKey,
-              flakeRef: nixFlakeRef
-            });
-            continue;
-          }
-        }
+    }
+    if (capabilityRegistry) {
+      const resolvedDecls = resolveExternalMcpDeclarations(projectDir, sessionMeta?.sessionId);
+      if (resolvedDecls.length > 0) {
+        externalMcpManager = new ExternalMcpManager(
+          capabilityRegistry,
+          secretProvider,
+          sessionMeta?.sessionId
+        );
+        await externalMcpManager.start(resolvedDecls);
+      }
+    } else if (driverType === "claude-sdk") {
+      const mcpLog = createLogger({
+        kind: "mcp",
+        subkind: "wiring",
+        instance: sessionMeta?.sessionId ?? "no-session"
+      });
+      const resolvedDecls = resolveExternalMcpDeclarations(projectDir, sessionMeta?.sessionId);
+      for (const decl of resolvedDecls) {
         const serverConfig = toSdkMcpServerConfig(
-          resolvedDecl,
+          decl,
           secretProvider
         );
         if (serverConfig) {
           mcpServers = { ...mcpServers ?? {}, [decl.id]: serverConfig };
-          const declLog = createLogger({ kind: "mcp", subkind: decl.id });
-          declLog.info("MCP server registered", {
+          createLogger({ kind: "mcp", subkind: decl.id }).info("MCP server registered", {
             transport: decl.transport ?? "stdio",
-            ...decl.transport === "stdio" || !decl.transport ? { command: resolvedDecl.command, args: resolvedDecl.args } : { url: decl.url }
+            ...decl.transport === "stdio" || !decl.transport ? { command: decl.command, args: decl.args } : { url: decl.url }
           });
         } else {
           mcpLog.error("MCP server config invalid (translation returned null)", void 0, {
@@ -1056,7 +1249,8 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
         }
       }
     }
-    if (!resourceManager && driverType !== "claude-sdk") return noopResult;
+    if (!resourceManager && driverType !== "claude-sdk" && !externalMcpManager?.hasServers())
+      return noopResult;
     const startWatching = () => {
       if (resourceManager && watch?.onFileChanged) {
         const dedupTtlMs = watch.dedupTtlMs ?? 500;
@@ -1077,6 +1271,10 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
       }
     };
     const dispose = async () => {
+      try {
+        await externalMcpManager?.dispose();
+      } catch {
+      }
       if (workspacePluginToShutdown) {
         try {
           await workspacePluginToShutdown.shutdown();
@@ -1100,15 +1298,6 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
     return noopResult;
   }
 }
-var RESERVED_MCP_SERVER_IDS = /* @__PURE__ */ new Set(["skaile-connectors", "skaile-workspace"]);
-function resolveRecordSecrets(record, secrets) {
-  if (!secrets) return record;
-  const resolved = {};
-  for (const [k, v] of Object.entries(record)) {
-    resolved[k] = secrets.resolve(v) ?? v;
-  }
-  return resolved;
-}
 function toSdkMcpServerConfig(decl, secrets) {
   const transport = decl.transport ?? "stdio";
   if (transport === "stdio") {
@@ -1187,7 +1376,8 @@ async function createAgentSession(config) {
     },
     config.tokenMediator,
     config.preMintedSecrets,
-    config.deferFilesystemMounts
+    config.deferFilesystemMounts,
+    config.capabilityRegistry
   );
   const wsConfig = wsConfigOverride ?? resolveSkWorkspaceConfig(projectDir);
   const contextSection = buildContextSection(wsConfig.agent?.context);
@@ -3046,6 +3236,11 @@ async function startAgentServer(opts) {
       deferFilesystemMounts: true,
       onLog: (line) => log(`[serve] ${line}`),
       capabilities: buildCapabilityHooks(),
+      // Hand the registry to the session builder so external (declarative /
+      // recipe-backed) MCP servers are spawned by the RUNNER and their tools
+      // registered as `mcp`-origin capabilities — works on every driver, no
+      // dependence on the claude-agent-sdk `mcpServers` query option.
+      capabilityRegistry,
       // v3: pre-minted credentials replace the tokenMediator for initial mints.
       // Refresh routes through `host.refresh_credential` (invoked from the
       // bridge driver's onAuthError callback). The legacy `tokenMediator`
@@ -3065,6 +3260,18 @@ async function startAgentServer(opts) {
   let secretProvider;
   let runtimeIdentity;
   let preMintedSecrets;
+  try {
+    const { skillsDir } = resolveDriverPaths({
+      driver: opts.driver ?? wsConfig.agent_config?.default?.driver ?? "claude-sdk"
+    });
+    const stagedSkills = stageMaterializedSkills(opts.projectDir, skillsDir);
+    if (stagedSkills.length > 0) {
+      log(
+        `[serve] staged ${stagedSkills.length} materialized skill(s): ${stagedSkills.join(", ")}`
+      );
+    }
+  } catch {
+  }
   if (secretsMode === "provisioned") {
     log("[serve] secrets mode: provisioned \u2014 waiting for provision_secrets command");
   } else {
@@ -4303,5 +4510,5 @@ function touchSession(state) {
 }
 
 export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildContextSection, buildEnvironmentSection, builtinCapabilities, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, createAgentSession, createSessionStimulusBus, defineCapability, deleteSession, emitSystemPromptComposed, ensureGitConfigInclude, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, installPreInitRingSink, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, newSession, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveMixin, runAgentChat, saveSession, setCurrentSession, startAgentServer, touchSession, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-JQBHCJ6N.js.map
-//# sourceMappingURL=chunk-JQBHCJ6N.js.map
+//# sourceMappingURL=chunk-BJWUSHC4.js.map
+//# sourceMappingURL=chunk-BJWUSHC4.js.map