@minicor/mcp-server 3.3.1 → 3.3.4

package/dist/codemode.js

@@ -0,0 +1,726 @@
+import { Worker } from "node:worker_threads";
+import { z } from "zod";
+import { json } from "./helpers.js";
+const RESERVED_WORDS = new Set([
+    "abstract",
+    "arguments",
+    "await",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "function",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "int",
+    "interface",
+    "let",
+    "long",
+    "native",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "short",
+    "static",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "transient",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "volatile",
+    "while",
+    "with",
+    "yield",
+]);
+function sanitizeToolName(name) {
+    let sanitized = name.replace(/[^A-Za-z0-9_$]/g, "_");
+    if (!sanitized || /^[0-9]/.test(sanitized))
+        sanitized = `_${sanitized}`;
+    if (RESERVED_WORDS.has(sanitized))
+        sanitized = `${sanitized}_`;
+    return sanitized;
+}
+function getDef(schema) {
+    return schema?._def ?? schema?.def;
+}
+function getTypeName(schema) {
+    const def = getDef(schema);
+    const typeName = def?.typeName ?? def?.type;
+    return typeof typeName === "string" ? typeName : "";
+}
+function isOptionalSchema(schema) {
+    const typeName = getTypeName(schema);
+    return (typeName === "optional" ||
+        typeName === "default" ||
+        typeName === "ZodOptional" ||
+        typeName === "ZodDefault" ||
+        typeof schema?.isOptional === "function" && schema.isOptional());
+}
+function unwrapSchema(schema) {
+    let current = schema;
+    for (let i = 0; i < 8; i += 1) {
+        const typeName = getTypeName(current);
+        const def = getDef(current);
+        if (typeName === "optional" ||
+            typeName === "nullable" ||
+            typeName === "default" ||
+            typeName === "catch" ||
+            typeName === "ZodOptional" ||
+            typeName === "ZodNullable" ||
+            typeName === "ZodDefault" ||
+            typeName === "ZodCatch") {
+            current = def?.innerType ?? def?.type ?? def?.schema ?? current;
+            continue;
+        }
+        return current;
+    }
+    return current;
+}
+function literalValue(schema) {
+    const def = getDef(schema);
+    if ("value" in (def ?? {}))
+        return def.value;
+    if (Array.isArray(def?.values))
+        return def.values[0];
+    return undefined;
+}
+function enumValues(schema) {
+    const def = getDef(schema);
+    if (Array.isArray(def?.values))
+        return def.values.map(String);
+    if (Array.isArray(def?.options))
+        return def.options.map(String);
+    if (def?.entries && typeof def.entries === "object") {
+        return Object.values(def.entries).map(String);
+    }
+    if (schema?.enum && typeof schema.enum === "object") {
+        return Object.values(schema.enum).map(String);
+    }
+    return [];
+}
+function objectShape(schema) {
+    const def = getDef(schema);
+    const shape = def?.shape;
+    if (typeof shape === "function")
+        return shape();
+    if (shape && typeof shape === "object")
+        return shape;
+    return {};
+}
+function schemaToType(schema) {
+    const rawTypeName = getTypeName(schema);
+    const unwrapped = unwrapSchema(schema);
+    const typeName = getTypeName(unwrapped) || rawTypeName;
+    const def = getDef(unwrapped);
+    switch (typeName) {
+        case "string":
+        case "ZodString":
+            return "string";
+        case "number":
+        case "ZodNumber":
+            return "number";
+        case "boolean":
+        case "ZodBoolean":
+            return "boolean";
+        case "bigint":
+        case "ZodBigInt":
+            return "bigint";
+        case "date":
+        case "ZodDate":
+            return "Date";
+        case "unknown":
+        case "any":
+        case "ZodUnknown":
+        case "ZodAny":
+            return "unknown";
+        case "never":
+        case "ZodNever":
+            return "never";
+        case "null":
+        case "ZodNull":
+            return "null";
+        case "literal":
+        case "ZodLiteral":
+            return JSON.stringify(literalValue(unwrapped));
+        case "enum":
+        case "nativeEnum":
+        case "ZodEnum": {
+            const values = enumValues(unwrapped);
+            return values.length > 0 ? values.map((v) => JSON.stringify(v)).join(" | ") : "string";
+        }
+        case "array":
+        case "ZodArray": {
+            const item = def?.element ?? def?.type ?? def?.items;
+            return `${schemaToType(item)}[]`;
+        }
+        case "record":
+        case "ZodRecord": {
+            const valueType = def?.valueType ?? def?.valueSchema;
+            return `Record<string, ${valueType ? schemaToType(valueType) : "unknown"}>`;
+        }
+        case "object":
+        case "ZodObject": {
+            const entries = Object.entries(objectShape(unwrapped));
+            if (entries.length === 0)
+                return "Record<string, unknown>";
+            const props = entries.map(([key, value]) => {
+                const optional = isOptionalSchema(value);
+                return `${key}${optional ? "?" : ""}: ${schemaToType(value)}`;
+            });
+            return `{ ${props.join("; ")} }`;
+        }
+        case "union":
+        case "ZodUnion": {
+            const options = Array.isArray(def?.options) ? def.options : [];
+            return options.length > 0
+                ? options.map((option) => schemaToType(option)).join(" | ")
+                : "unknown";
+        }
+        case "intersection":
+        case "ZodIntersection":
+            return `${schemaToType(def?.left)} & ${schemaToType(def?.right)}`;
+        case "tuple":
+        case "ZodTuple": {
+            const items = Array.isArray(def?.items) ? def.items : [];
+            return `[${items.map((item) => schemaToType(item)).join(", ")}]`;
+        }
+        default:
+            return "unknown";
+    }
+}
+function getDescription(schema) {
+    const description = schema?.description ?? getDef(schema)?.description;
+    return typeof description === "string" && description.length > 0
+        ? description
+        : undefined;
+}
+function buildToolDoc(tool) {
+    const parameters = Object.entries(tool.inputSchema ?? {}).map(([name, schema]) => ({
+        name,
+        optional: isOptionalSchema(schema),
+        type: schemaToType(schema),
+        description: getDescription(schema),
+    }));
+    const inputTypeName = `${toPascalCase(tool.apiName)}Input`;
+    const lines = [
+        `interface ${inputTypeName} {`,
+        ...parameters.map((param) => {
+            const comment = param.description ? `  /** ${param.description.replace(/\*\//g, "* /")} */\n` : "";
+            return `${comment}  ${param.name}${param.optional ? "?" : ""}: ${param.type};`;
+        }),
+        "}",
+        `declare const minicor: { ${tool.apiName}: (input: ${inputTypeName}) => Promise<unknown>; };`,
+    ];
+    return {
+        name: tool.name,
+        apiName: tool.apiName,
+        qualifiedName: `minicor.${tool.apiName}`,
+        description: tool.description,
+        parameters,
+        signature: lines.join("\n"),
+    };
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^A-Za-z0-9]+|_/g)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("") || "Tool";
+}
+function compactDoc(doc) {
+    return {
+        name: doc.qualifiedName,
+        tool: doc.name,
+        description: doc.description,
+        parameters: doc.parameters.map((param) => ({
+            name: param.name,
+            type: param.type,
+            optional: param.optional,
+            description: param.description,
+        })),
+    };
+}
+function parseTextValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]")) ||
+        trimmed === "null" ||
+        trimmed === "true" ||
+        trimmed === "false") {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+function toolResultToValue(result) {
+    if (!result || typeof result !== "object")
+        return result;
+    const maybeTool = result;
+    if (!Array.isArray(maybeTool.content))
+        return result;
+    const textItems = maybeTool.content.filter((item) => item.type === "text" && typeof item.text === "string");
+    if (maybeTool.content.length === 1 && textItems.length === 1) {
+        return parseTextValue(textItems[0].text ?? "");
+    }
+    if (textItems.length === maybeTool.content.length) {
+        return textItems.map((item) => item.text ?? "").join("\n");
+    }
+    return result;
+}
+function extractRenderableContent(result) {
+    if (!result || typeof result !== "object")
+        return [];
+    const maybeTool = result;
+    if (!Array.isArray(maybeTool.content))
+        return [];
+    return maybeTool.content.filter((item) => item.type !== "text");
+}
+function sanitizeForText(value, seen = new WeakSet()) {
+    if (!value || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        return "[Circular]";
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeForText(item, seen));
+    }
+    const record = value;
+    const copy = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (key === "data" &&
+            typeof item === "string" &&
+            (record.type === "image" || record.type === "audio" || record.type === "resource")) {
+            copy[key] = `[${item.length} base64 chars omitted from text summary]`;
+            continue;
+        }
+        copy[key] = sanitizeForText(item, seen);
+    }
+    return copy;
+}
+const WORKER_SOURCE = `
+const { parentPort, workerData } = require("node:worker_threads");
+const vm = require("node:vm");
+
+const pending = new Map();
+let seq = 0;
+
+function serializeError(error) {
+  if (!error) return "Unknown error";
+  if (error && typeof error.stack === "string") return error.stack;
+  if (error && typeof error.message === "string") return error.message;
+  return String(error);
+}
+
+function send(type, payload) {
+  parentPort.postMessage({ type, ...payload });
+}
+
+function hostCall(tool, args) {
+  return new Promise((resolve, reject) => {
+    const id = ++seq;
+    pending.set(id, { resolve, reject });
+    send("toolCall", { id, tool, args: args ?? {} });
+  });
+}
+
+parentPort.on("message", (message) => {
+  const entry = pending.get(message.id);
+  if (!entry) return;
+  pending.delete(message.id);
+  if (message.type === "toolResult") {
+    entry.resolve(message.result);
+  } else if (message.type === "toolError") {
+    entry.reject(new Error(message.error));
+  }
+});
+
+function searchTools(query, limit = 12) {
+  const q = String(query ?? "").toLowerCase();
+  const terms = q.split(/\\s+/).filter(Boolean);
+  const scored = workerData.tools.map((tool) => {
+    const haystack = [tool.qualifiedName, tool.name, tool.description, ...tool.parameters.map((p) => [p.name, p.description, p.type].filter(Boolean).join(" "))].join(" ").toLowerCase();
+    const score = terms.length === 0 ? 1 : terms.reduce((sum, term) => sum + (haystack.includes(term) ? 1 : 0), 0);
+    return { tool, score };
+  }).filter((entry) => entry.score > 0);
+  scored.sort((a, b) => b.score - a.score || a.tool.qualifiedName.localeCompare(b.tool.qualifiedName));
+  return scored.slice(0, limit).map((entry) => ({
+    name: entry.tool.qualifiedName,
+    tool: entry.tool.name,
+    description: entry.tool.description,
+    parameters: entry.tool.parameters
+  }));
+}
+
+function describeTool(name) {
+  const needle = String(name ?? "");
+  const normalized = needle.startsWith("minicor.") ? needle.slice("minicor.".length) : needle;
+  const tool = workerData.tools.find((candidate) => candidate.qualifiedName === needle || candidate.apiName === normalized || candidate.name === normalized);
+  if (!tool) {
+    return {
+      error: "Tool not found",
+      query: needle,
+      hint: "Call await codemode.search(query) to find available tools."
+    };
+  }
+  return tool;
+}
+
+function makeConnector(includeDiscovery) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return undefined;
+      if (prop === "then") return undefined;
+      if (includeDiscovery) {
+        if (prop === "search") return (query, limit) => Promise.resolve(searchTools(query, limit));
+        if (prop === "describe") return (name) => Promise.resolve(describeTool(name));
+        if (prop === "list") return () => Promise.resolve(workerData.tools.map((tool) => ({
+          name: tool.qualifiedName,
+          tool: tool.name,
+          description: tool.description
+        })));
+      }
+      return (args = {}) => hostCall(prop, args);
+    }
+  });
+}
+
+function normalizeCode(code) {
+  const trimmed = String(code ?? "").trim();
+  const unwrapped = trimmed.startsWith("(") && trimmed.endsWith(")")
+    ? trimmed.slice(1, -1).trim()
+    : trimmed;
+  if (/^(async\\s*)?\\(?\\s*(?:[A-Za-z_$][\\w$]*\\s*)?\\)?\\s*=>/.test(unwrapped) || unwrapped.startsWith("async function") || unwrapped.startsWith("function")) {
+    return "__codemodeRun((" + trimmed + ")());";
+  }
+  return "__codemodeRun((async () => {\\n" + code + "\\n})());";
+}
+
+const logs = [];
+const consoleProxy = {};
+for (const level of ["log", "info", "warn", "error"]) {
+  consoleProxy[level] = (...args) => {
+    const rendered = args.map((arg) => {
+      if (typeof arg === "string") return arg;
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    }).join(" ");
+    logs.push({ level, message: rendered });
+    send("log", { level, message: rendered });
+  };
+}
+
+const context = vm.createContext({
+  console: consoleProxy,
+  codemode: makeConnector(true),
+  minicor: makeConnector(false),
+  setTimeout,
+  clearTimeout,
+  Promise,
+  JSON,
+  Math,
+  Date,
+  RegExp,
+  String,
+  Number,
+  Boolean,
+  Array,
+  Object,
+  Map,
+  Set,
+  URL,
+  URLSearchParams,
+  TextEncoder,
+  TextDecoder,
+  __codemodeRun: async (promise) => {
+    try {
+      const result = await promise;
+      send("result", { result, logs });
+    } catch (error) {
+      send("error", { error: serializeError(error), logs });
+    }
+  }
+}, {
+  codeGeneration: { strings: false, wasm: false }
+});
+
+try {
+  const script = new vm.Script(normalizeCode(workerData.code), {
+    filename: "minicor-codemode.js",
+    displayErrors: true,
+  });
+  script.runInContext(context, { timeout: workerData.syncTimeoutMs });
+} catch (error) {
+  send("error", { error: serializeError(error), logs });
+}
+`;
+export class CodeModeToolRegistry {
+    server;
+    tools = [];
+    byApiName = new Map();
+    exposeLegacyTools;
+    defaultTimeoutMs;
+    maxTimeoutMs;
+    constructor(server, options = {}) {
+        this.server = server;
+        this.exposeLegacyTools = options.exposeLegacyTools ?? false;
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? 30_000;
+        this.maxTimeoutMs = options.maxTimeoutMs ?? 120_000;
+    }
+    tool(name, ...args) {
+        const handler = args[args.length - 1];
+        if (typeof handler !== "function") {
+            throw new Error(`Tool ${name} did not provide a handler.`);
+        }
+        let description = "";
+        let inputSchema = {};
+        if (typeof args[0] === "string") {
+            description = args[0];
+            inputSchema = args[1] && typeof args[1] === "object" ? args[1] : {};
+        }
+        else if (args[0] && typeof args[0] === "object") {
+            inputSchema = args[0];
+        }
+        const apiName = this.uniqueApiName(name);
+        const tool = {
+            name,
+            apiName,
+            description,
+            inputSchema,
+            handler,
+        };
+        this.tools.push(tool);
+        this.byApiName.set(apiName, tool);
+        if (this.exposeLegacyTools) {
+            return this.server.tool(name, ...args);
+        }
+        return undefined;
+    }
+    prompt(...args) {
+        return this.server.prompt(...args);
+    }
+    registerCodeModeTool() {
+        const description = [
+            "Run JavaScript code that orchestrates the Minicor MCP API.",
+            "Inside the sandbox, call Minicor tools as async functions on the `minicor` global, for example:",
+            "`const workspaces = await minicor.list_workspaces({});`",
+            "Use `await codemode.search(\"workflow\")` to discover methods and `await codemode.describe(\"minicor.create_rpa_flow\")` for parameter docs.",
+            "Return a small JSON-serializable value or use console.log for progress. Tool calls should be awaited sequentially when actions depend on previous results.",
+            "The sandbox has no require/process/fetch access; effects go through Minicor tool methods.",
+        ].join("\n");
+        this.server.tool("codemode", description, {
+            code: z
+                .string()
+                .describe("JavaScript code to run. It is wrapped in an async function, so top-level await and return are supported. Example: `const ws = await minicor.list_workspaces({}); return ws;`"),
+            timeoutMs: z
+                .number()
+                .int()
+                .positive()
+                .max(this.maxTimeoutMs)
+                .optional()
+                .describe(`Optional execution timeout in milliseconds. Default ${this.defaultTimeoutMs}.`),
+        }, async ({ code, timeoutMs }) => {
+            const result = await this.execute(code, timeoutMs);
+            const renderable = extractRenderableContent(result.result);
+            const textResult = {
+                ...result,
+                ...(result.result !== undefined
+                    ? { result: sanitizeForText(result.result) }
+                    : {}),
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: json(textResult),
+                    },
+                    ...renderable.map((item) => ({
+                        ...item,
+                        type: item.type,
+                    })),
+                ],
+            };
+        });
+    }
+    docs() {
+        return this.tools.map(buildToolDoc);
+    }
+    async execute(code, timeoutMs) {
+        const timeout = Math.min(timeoutMs ?? this.defaultTimeoutMs, this.maxTimeoutMs);
+        const logs = [];
+        const startedAt = Date.now();
+        return new Promise((resolve) => {
+            let settled = false;
+            const worker = new Worker(WORKER_SOURCE, {
+                eval: true,
+                workerData: {
+                    code,
+                    tools: this.docs(),
+                    syncTimeoutMs: Math.min(timeout, 5_000),
+                },
+            });
+            const finish = (payload) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                void worker.terminate();
+                resolve({
+                    status: payload.status,
+                    executionMs: Date.now() - startedAt,
+                    ...(payload.result !== undefined ? { result: payload.result } : {}),
+                    ...(payload.error ? { error: payload.error } : {}),
+                    logs: payload.logs ?? logs,
+                });
+            };
+            const timer = setTimeout(() => {
+                finish({
+                    status: "error",
+                    error: `Code mode execution timed out after ${timeout}ms.`,
+                    logs,
+                });
+            }, timeout);
+            worker.on("message", (message) => {
+                if (message?.type === "log") {
+                    logs.push({ level: message.level, message: message.message });
+                    return;
+                }
+                if (message?.type === "toolCall") {
+                    void this.invoke(message.tool, message.args)
+                        .then((result) => {
+                        worker.postMessage({ type: "toolResult", id: message.id, result });
+                    })
+                        .catch((error) => {
+                        worker.postMessage({
+                            type: "toolError",
+                            id: message.id,
+                            error: error?.message ?? String(error),
+                        });
+                    });
+                    return;
+                }
+                if (message?.type === "result") {
+                    finish({
+                        status: "completed",
+                        result: message.result,
+                        logs: message.logs ?? logs,
+                    });
+                    return;
+                }
+                if (message?.type === "error") {
+                    finish({
+                        status: "error",
+                        error: message.error,
+                        logs: message.logs ?? logs,
+                    });
+                }
+            });
+            worker.on("error", (error) => {
+                finish({
+                    status: "error",
+                    error: error.stack ?? error.message,
+                    logs,
+                });
+            });
+            worker.on("exit", (codeValue) => {
+                if (!settled && codeValue !== 0) {
+                    finish({
+                        status: "error",
+                        error: `Code mode worker exited with code ${codeValue}.`,
+                        logs,
+                    });
+                }
+            });
+        });
+    }
+    async invoke(apiName, args) {
+        const tool = this.byApiName.get(apiName);
+        if (!tool) {
+            throw new Error(`Unknown Minicor code-mode method "${apiName}". Use await codemode.search("...") to discover available methods.`);
+        }
+        const result = await tool.handler(args ?? {});
+        return toolResultToValue(result);
+    }
+    uniqueApiName(name) {
+        const base = sanitizeToolName(name);
+        let candidate = base;
+        let suffix = 2;
+        while (this.byApiName.has(candidate)) {
+            candidate = `${base}_${suffix}`;
+            suffix += 1;
+        }
+        return candidate;
+    }
+}
+export function shouldUseCodeMode() {
+    const explicit = process.env.MINICOR_MCP_CODE_MODE;
+    if (explicit != null) {
+        return !["0", "false", "off", "no"].includes(explicit.toLowerCase());
+    }
+    return !["1", "true", "on", "yes"].includes((process.env.MINICOR_MCP_LEGACY_TOOLS ?? "").toLowerCase());
+}
+export function buildCodeModeInstructions(baseInstructions) {
+    return `${baseInstructions}
+
+CODE MODE:
+This MCP exposes Minicor capabilities through a code-mode surface by default. Use the \`codemode\` tool to run JavaScript that calls Minicor methods as \`await minicor.tool_name({ ... })\`.
+
+If the server starts unauthenticated and only exposes \`setup_account\`, call \`setup_account\` directly, authenticate, and restart the MCP server. Code mode is enabled for authenticated sessions.
+
+Discovery inside code mode:
+- \`await codemode.search("workflow")\` finds relevant Minicor methods.
+- \`await codemode.describe("minicor.session_start")\` returns TypeScript-style parameter docs.
+- \`await codemode.list()\` lists all available methods.
+
+If the current directory contains a minicor.json file, your first MCP action should be a \`codemode\` call whose code invokes \`await minicor.session_start({ directory: "<current directory>" })\`. Before ending work, invoke \`await minicor.session_end(...)\` through code mode.
+
+Set MINICOR_MCP_LEGACY_TOOLS=1 or MINICOR_MCP_CODE_MODE=0 to expose the legacy one-tool-per-operation MCP surface.`;
+}
+export function asMcpServer(registry) {
+    return registry;
+}
+export function compactToolDocs(tools) {
+    return tools.map(compactDoc);
+}
+//# sourceMappingURL=codemode.js.map