@actiondock/mcp 2.0.11-beta.0 → 2.0.12

package/package.json

@@ -1,38 +1,39 @@
 {
   "name": "@actiondock/mcp",
-  "version": "2.0.11-beta.0",
+  "version": "2.0.12",
   "description": "ActionDock MCP Adapter for exposing Actions as Model Context Protocol (MCP) Tools",
   "type": "module",
-  "main": "./src/index.ts",
-  "module": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./src/index.ts",
-      "types": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=22.13.0"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
+    "build": "bun run ../../scripts/build.ts",
     "test": "bun test"
   },
   "dependencies": {
-    "@actiondock/core": "2.0.11-beta.0",
-    "@actiondock/sdk": "2.0.11-beta.0",
+    "@actiondock/core": "^2.0.12",
+    "@actiondock/sdk": "^2.0.12",
     "@modelcontextprotocol/server": "^2.0.0"
   },
   "devDependencies": {
-    "@types/bun": "latest",
     "typescript": "^5.7.0"
   },
   "keywords": [

package/src/adapter.ts

@@ -1,437 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import {
-  ActionRunner,
-  createStorage,
-  ExecutionManager,
-  findProjectRoot,
-  listLinkedPackages,
-  loadActions,
-  loadProjectConfig,
-  resolvePackageRoot,
-  ServerRuntimeRegistry,
-} from "@actiondock/core";
-import type { ProjectConfig, RuntimeStorage } from "@actiondock/core";
-import type { ActionDefinition, ExecutionResult, RunRecord } from "@actiondock/sdk";
-import { McpServer } from "@modelcontextprotocol/server";
-import { toMcpSchema } from "./schemas";
-import { toMcpTaskPayload, type ActionDockMcpOptions } from "./types";
-
-/**
- * 判断目标值是否为普通对象（Plain Object）。
- * 
- * @param value 待检查的值
- */
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-/**
- * 将 ActionDock 标准的 ExecutionResult 信封结构转换为 MCP 协议规范的 Tool Call 返回结果。
- * 
- * @param result ExecutionResult 结果对象
- */
-export function toMcpResult(result: ExecutionResult) {
-  if (result.ok) {
-    const structuredContent = isPlainObject(result.data)
-      ? (result.data as Record<string, unknown>)
-      : { value: result.data };
-
-    return {
-      content: [
-        {
-          type: "text" as const,
-          text: JSON.stringify(result),
-        },
-      ],
-      structuredContent,
-    };
-  }
-
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text" as const,
-        text: JSON.stringify(result),
-      },
-    ],
-  };
-}
-
-interface ResolvedTarget {
-  projectRoot: string;
-  config: ProjectConfig;
-  actions: Map<string, ActionDefinition>;
-  storage: RuntimeStorage;
-  runner: ActionRunner;
-}
-
-function createMcpToolCallback(
-  runner: ActionRunner,
-  actionId: string,
-  executionManager: ExecutionManager,
-  timeoutMs?: number
-) {
-  return async (input: any, ctx: any) => {
-    const isAsync = Boolean(
-      input &&
-        typeof input === "object" &&
-        (input.execution?.mode === "async" ||
-          input.__async === true ||
-          input.async === true)
-    );
-    const signal = ctx.mcpReq?.signal;
-
-    if (isAsync) {
-      const handle = runner.start(actionId, input, {
-        signal,
-        timeoutMs,
-      });
-      executionManager.register(handle);
-
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: JSON.stringify({
-              ok: true,
-              runId: handle.runId,
-              taskId: handle.runId,
-              status: "running",
-            }),
-          },
-        ],
-      };
-    }
-
-    const handle = runner.start(actionId, input, {
-      signal,
-      timeoutMs,
-    });
-    executionManager.register(handle);
-    const result = await handle.result;
-    return toMcpResult(result);
-  };
-}
-
-export type ActionDockMcpServer = McpServer & {
-  close: () => Promise<void>;
-};
-
-/**
- * Creates and configures an McpServer instance bound to one or more ActionDock packages with Tasks extension support.
- */
-export async function createActionDockMcpServer(
-  options: ActionDockMcpOptions = {}
-): Promise<ActionDockMcpServer> {
-  const targetRoots: string[] = [];
-  if (options.projectRoot) {
-    targetRoots.push(options.projectRoot);
-  }
-  if (options.projectRoots) {
-    targetRoots.push(...options.projectRoots);
-  }
-
-  const targetPackages: string[] = [];
-  if (options.packageId) {
-    targetPackages.push(options.packageId);
-  }
-  if (options.packageIds) {
-    targetPackages.push(...options.packageIds);
-  }
-
-  const resolvedRoots = new Set<string>();
-
-  // 1. Handle --all: discover all linked packages from registry
-  if (options.all) {
-    const linked = listLinkedPackages(options.customHome);
-    for (const pkg of linked) {
-      if (existsSync(pkg.path)) {
-        resolvedRoots.add(resolve(pkg.path));
-      }
-    }
-    const currentRoot = findProjectRoot(process.cwd());
-    if (currentRoot) {
-      resolvedRoots.add(resolve(currentRoot));
-    }
-  }
-
-  // 2. Handle specific package IDs
-  for (const pkgId of targetPackages) {
-    const root = resolvePackageRoot(pkgId, undefined, options.customHome);
-    if (!root || !existsSync(root)) {
-      throw new Error(`Package '${pkgId}' not found in registry`);
-    }
-    resolvedRoots.add(resolve(root));
-  }
-
-  // 3. Handle specific directory paths
-  for (const dir of targetRoots) {
-    const absPath = resolve(dir);
-    const root = findProjectRoot(absPath);
-    if (!root) {
-      throw new Error(
-        `Project root '${dir}' is not a valid ActionDock package (actiondock.json not found)`
-      );
-    }
-    resolvedRoots.add(resolve(root));
-  }
-
-  // 4. Default fallback: current working directory
-  if (resolvedRoots.size === 0 && !options.all) {
-    const currentRoot = findProjectRoot(process.cwd());
-    if (currentRoot) {
-      resolvedRoots.add(resolve(currentRoot));
-    }
-  }
-
-  const runtimeRegistry = options.runtimeRegistry ?? new ServerRuntimeRegistry();
-  const executionManager = options.executionManager ?? runtimeRegistry.executionManager;
-  const targets: ResolvedTarget[] = [];
-
-  // Handle case where options.actions is provided directly (e.g. unit tests or virtual packages)
-  if (resolvedRoots.size === 0 && options.actions) {
-    const dummyConfig: ProjectConfig = {
-      id: "virtual",
-      name: "Virtual Package",
-      version: "2.0.0",
-      description: "In-memory virtual package",
-      actionsDir: "actions",
-      playbooksDir: "playbooks",
-    };
-    const storage = options.storage ?? runtimeRegistry.getStorage("virtual");
-    const runner = new ActionRunner({
-      packageId: dummyConfig.id,
-      storage,
-      projectConfig: dummyConfig,
-      configOverrides: options.configOverrides,
-      actions: options.actions,
-    });
-    targets.push({
-      projectRoot: "virtual",
-      config: dummyConfig,
-      actions: options.actions,
-      storage,
-      runner,
-    });
-  } else {
-    if (resolvedRoots.size === 0) {
-      throw new Error(
-        "No ActionDock project root found. Run inside an ActionDock package or specify --dir / --package / --all."
-      );
-    }
-
-    for (const root of resolvedRoots) {
-      const projectConfig = loadProjectConfig(root);
-      const actions =
-        options.actions && resolvedRoots.size === 1
-          ? options.actions
-          : await loadActions(root, projectConfig.actionsDir);
-
-      const storage =
-        options.storage && resolvedRoots.size === 1
-          ? options.storage
-          : runtimeRegistry.getStorage(projectConfig.id, root);
-
-      const runner = new ActionRunner({
-        packageId: projectConfig.id,
-        storage,
-        projectConfig,
-        configOverrides: options.configOverrides,
-        actions,
-      });
-
-      targets.push({
-        projectRoot: root,
-        config: projectConfig,
-        actions,
-        storage,
-        runner,
-      });
-    }
-  }
-
-  const isMultiPackage = targets.length > 1;
-
-  // Check action ID collision across packages
-  const actionIdCounts = new Map<string, number>();
-  for (const target of targets) {
-    for (const actionId of target.actions.keys()) {
-      actionIdCounts.set(actionId, (actionIdCounts.get(actionId) || 0) + 1);
-    }
-  }
-
-  const serverName =
-    targets.length === 1
-      ? targets[0].config.id || targets[0].config.name || "actiondock"
-      : "actiondock";
-  const serverVersion =
-    targets.length === 1 ? targets[0].config.version || "2.0.0" : "2.0.0";
-
-  const server = new McpServer({
-    name: serverName,
-    version: serverVersion,
-  });
-
-  (server.server as any).registerCapabilities({
-    tasks: {
-      listChanged: true,
-      cancel: {},
-    },
-  });
-
-  // 1. Register Action Tools across all targets
-  for (const target of targets) {
-    for (const action of target.actions.values()) {
-      const count = actionIdCounts.get(action.id) || 1;
-      const toolName = count > 1 ? `${target.config.id}_${action.id}` : action.id;
-      const description = isMultiPackage
-        ? `[${target.config.id}] ${action.description || ""}`
-        : action.description;
-
-      server.registerTool(
-        toolName,
-        {
-          description,
-          inputSchema: toMcpSchema(action.inputSchema),
-          outputSchema: action.outputSchema ? toMcpSchema(action.outputSchema) : undefined,
-        },
-        createMcpToolCallback(
-          target.runner,
-          action.id,
-          executionManager,
-          options.timeoutMs
-        )
-      );
-    }
-  }
-
-  const storages = targets.map((t) => t.storage);
-
-  // 2. Register Tasks extension endpoints: tasks/get
-  (server.server as any).setRequestHandler("tasks/get", async (req: any) => {
-    const taskId = req.params?.taskId;
-    if (!taskId) {
-      throw new Error("taskId parameter is required for tasks/get");
-    }
-    for (const storage of storages) {
-      const run = storage.getRun(taskId);
-      if (run) {
-        return {
-          task: toMcpTaskPayload(run),
-        };
-      }
-    }
-    throw new Error(`Task '${taskId}' not found`);
-  });
-
-  // 3. Register Tasks extension endpoints: tasks/cancel
-  (server.server as any).setRequestHandler("tasks/cancel", async (req: any) => {
-    const taskId = req.params?.taskId;
-    if (!taskId) {
-      throw new Error("taskId parameter is required for tasks/cancel");
-    }
-    const activeHandle = executionManager.get(taskId);
-    if (activeHandle) {
-      executionManager.cancel(taskId, req.params?.reason || "Cancelled via MCP tasks/cancel");
-      return {
-        taskId,
-        status: "cancelled",
-      };
-    }
-    for (const storage of storages) {
-      const run = storage.getRun(taskId);
-      if (run) {
-        if (run.status === "running") {
-          storage.updateRun(taskId, "cancelled", undefined, {
-            code: "ACTION_CANCELLED",
-            message: req.params?.reason || "Cancelled via MCP tasks/cancel",
-          });
-        }
-        return {
-          taskId,
-          status: "cancelled",
-        };
-      }
-    }
-    throw new Error(`Task '${taskId}' not found`);
-  });
-
-  // 4. Register Tasks extension endpoints: tasks/list
-  (server.server as any).setRequestHandler("tasks/list", async (req: any) => {
-    const limit = typeof req.params?.limit === "number" ? req.params.limit : 50;
-    const actionId = req.params?.actionId;
-    const allRuns: RunRecord[] = [];
-    for (const storage of storages) {
-      const runs = storage.listRuns({ limit, actionId });
-      allRuns.push(...runs);
-    }
-    allRuns.sort(
-      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
-    );
-    const trimmed = allRuns.slice(0, limit);
-    return {
-      tasks: trimmed.map(toMcpTaskPayload),
-    };
-  });
-
-  const originalClose = server.close.bind(server);
-  let isClosed = false;
-
-  const closeFn = async (): Promise<void> => {
-    if (isClosed) return;
-    isClosed = true;
-
-    process.removeListener("exit", onProcessExit);
-
-    for (const storage of storages) {
-      try {
-        storage.close();
-      } catch {
-        // ignore
-      }
-    }
-
-    if (!options.runtimeRegistry) {
-      try {
-        runtimeRegistry.close();
-      } catch {
-        // ignore
-      }
-    }
-
-    try {
-      await originalClose();
-    } catch {
-      // ignore
-    }
-  };
-
-  const onProcessExit = () => {
-    for (const storage of storages) {
-      try {
-        storage.close();
-      } catch {
-        // ignore
-      }
-    }
-    if (!options.runtimeRegistry) {
-      try {
-        runtimeRegistry.close();
-      } catch {
-        // ignore
-      }
-    }
-  };
-
-  process.once("exit", onProcessExit);
-
-  (server as any).close = closeFn;
-
-  return server as ActionDockMcpServer;
-}

package/src/http.ts

@@ -1,163 +0,0 @@
-import {
-  isLoopbackHost,
-  launchHttpServer,
-  resolveCorsHeaders,
-  ServerRuntimeRegistry,
-  verifyBearerToken,
-} from "@actiondock/core";
-import { createMcpHandler } from "@modelcontextprotocol/server";
-import { createActionDockMcpServer } from "./adapter";
-import type { ActionDockMcpHttpOptions, ActionDockMcpHttpServerInstance } from "./types";
-
-/**
- * Starts an ActionDock MCP server over HTTP transport.
- */
-export function startMcpHttpServer(
-  options: ActionDockMcpHttpOptions = {}
-): ActionDockMcpHttpServerInstance {
-  const port = options.port ?? 5178;
-  const host = options.host ?? "127.0.0.1";
-  const token = options.token;
-
-  // Non-loopback address requires token authentication by default
-  if (!isLoopbackHost(host) && !token && !options.allowInsecureNoAuth) {
-    throw new Error(
-      "Authentication token is required when binding to a non-loopback address. Use --allow-insecure-no-auth to override."
-    );
-  }
-
-  const runtimeRegistry = new ServerRuntimeRegistry();
-
-  const handler = createMcpHandler(
-    () => {
-      return createActionDockMcpServer({
-        ...options,
-        runtimeRegistry,
-        executionManager: runtimeRegistry.executionManager,
-      });
-    },
-    {
-      onerror: (err) => {
-        process.stderr.write(`[MCP HTTP Error] ${err?.message || String(err)}\n`);
-      },
-    }
-  );
-
-  const server = launchHttpServer(port, host, async (req) => {
-      const origin = req.headers.get("origin");
-      const corsHeaders = resolveCorsHeaders(origin, options.corsOrigins);
-
-      if (req.method === "OPTIONS") {
-        return new Response(null, {
-          status: 204,
-          headers: corsHeaders,
-        });
-      }
-
-      const url = new URL(req.url);
-      const pathname = url.pathname;
-
-      // 1. Health check
-      if (pathname === "/health" || pathname === "/api/v1/health") {
-        if (!verifyBearerToken(req, token)) {
-          return new Response(
-            JSON.stringify({
-              ok: false,
-              error: {
-                code: "UNAUTHORIZED",
-                message: "Invalid or missing Bearer token",
-              },
-            }),
-            {
-              status: 401,
-              headers: {
-                "Content-Type": "application/json",
-                ...corsHeaders,
-              },
-            }
-          );
-        }
-        return new Response(
-          JSON.stringify({
-            status: "ok",
-            protocol: "mcp",
-            version: "2.0.0",
-            timestamp: new Date().toISOString(),
-          }),
-          {
-            status: 200,
-            headers: {
-              "Content-Type": "application/json",
-              ...corsHeaders,
-            },
-          }
-        );
-      }
-
-      // 2. Authentication check
-      if (!verifyBearerToken(req, token)) {
-        return new Response(
-          JSON.stringify({
-            jsonrpc: "2.0",
-            error: {
-              code: -32000,
-              message: "Unauthorized: Invalid or missing Bearer token",
-            },
-            id: null,
-          }),
-          {
-            status: 401,
-            headers: {
-              "Content-Type": "application/json",
-              ...corsHeaders,
-            },
-          }
-        );
-      }
-
-      // 3. Delegate MCP endpoint
-      if (pathname === "/mcp" || pathname === "/") {
-        const mcpResponse = await handler.fetch(req);
-        if (Object.keys(corsHeaders).length > 0) {
-          const newHeaders = new Headers(mcpResponse.headers);
-          for (const [k, v] of Object.entries(corsHeaders)) {
-            newHeaders.set(k, String(v));
-          }
-          return new Response(mcpResponse.body, {
-            status: mcpResponse.status,
-            statusText: mcpResponse.statusText,
-            headers: newHeaders,
-          });
-        }
-        return mcpResponse;
-      }
-
-      return new Response(
-        JSON.stringify({
-          error: "Not Found",
-        }),
-        {
-          status: 404,
-          headers: {
-            "Content-Type": "application/json",
-            ...corsHeaders,
-          },
-        }
-      );
-    }
-  );
-
-  const actualHost = host === "0.0.0.0" ? "127.0.0.1" : host;
-  const url = `http://${actualHost}:${server.port}`;
-
-  return {
-    port: server.port ?? port,
-    host,
-    url,
-    stop: () => {
-      runtimeRegistry.close();
-      server.stop(true);
-    },
-  };
-}
-

package/src/schemas.ts

@@ -1,19 +0,0 @@
-import type { JsonSchema } from "@actiondock/sdk";
-import { fromJsonSchema } from "@modelcontextprotocol/server";
-
-/**
- * Normalizes an ActionDock JSON Schema into a standard MCP Tool Schema.
- */
-export function toMcpSchema(schema?: JsonSchema) {
-  if (schema === undefined || schema === true) {
-    return fromJsonSchema({});
-  }
-
-  if (schema === false) {
-    return fromJsonSchema({
-      not: {},
-    });
-  }
-
-  return fromJsonSchema(schema as Record<string, unknown>);
-}