@drumcode/runner 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import {
+  DrumcodeRunner,
+  createServer
+} from "./chunk-VYYR5EI4.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+import { config } from "dotenv";
+
+// src/sse-server.ts
+import express from "express";
+import cors from "cors";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var demoTools = [
+  {
+    name: "drumcode_echo",
+    description: "Echo back the input arguments. Useful for testing.",
+    input_schema: {
+      type: "object",
+      properties: {
+        message: {
+          type: "string",
+          description: "The message to echo back"
+        }
+      },
+      required: ["message"]
+    }
+  },
+  {
+    name: "drumcode_http_get",
+    description: "Make an HTTP GET request to a URL and return the response.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch"
+        }
+      },
+      required: ["url"]
+    }
+  }
+];
+var arxivTools = [
+  {
+    name: "arxiv_search_papers",
+    description: "Search for academic papers on arXiv. Returns papers matching the query with optional filters.",
+    input_schema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Search query keywords (e.g., "machine learning", "quantum computing")'
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results to return (1-20)"
+        },
+        categories: {
+          type: "string",
+          description: 'Comma-separated arXiv categories to filter by (e.g., "cs.AI,cs.LG")'
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "arxiv_get_paper",
+    description: "Get detailed metadata and abstract for a specific paper by its arXiv ID.",
+    input_schema: {
+      type: "object",
+      properties: {
+        paper_id: {
+          type: "string",
+          description: 'The arXiv paper ID (e.g., "2301.07041" or "1706.03762")'
+        }
+      },
+      required: ["paper_id"]
+    }
+  },
+  {
+    name: "arxiv_search_by_author",
+    description: "Search for papers by a specific author on arXiv.",
+    input_schema: {
+      type: "object",
+      properties: {
+        author: {
+          type: "string",
+          description: "Author name to search for"
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results (1-20)"
+        }
+      },
+      required: ["author"]
+    }
+  },
+  {
+    name: "arxiv_search_by_category",
+    description: "Search for recent papers in a specific arXiv category.",
+    input_schema: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          description: 'arXiv category (e.g., "cs.AI", "math.CO", "physics.hep-th")'
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results (1-20)"
+        }
+      },
+      required: ["category"]
+    }
+  }
+];
+async function createSSEServer(options) {
+  const runner = new DrumcodeRunner(options);
+  const authContext = await runner.initializeAuth();
+  if (authContext.isAuthenticated) {
+    console.error(`[drumcode] Authenticated as: ${authContext.tokenName || "unnamed token"}`);
+    console.error(`[drumcode] Project ID: ${authContext.projectId}`);
+    if (authContext.profileId) {
+      console.error(`[drumcode] Permission profile: ${authContext.profileId}`);
+    }
+  } else if (options.token) {
+    console.error("[drumcode] Warning: Token provided but authentication failed");
+  }
+  const app = express();
+  app.use(cors({
+    origin: "*",
+    methods: ["GET", "POST", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization", "Mcp-Session-Id"],
+    exposedHeaders: ["Mcp-Session-Id"]
+  }));
+  app.use(express.json());
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      version: "0.1.0",
+      transport: "sse",
+      authenticated: authContext.isAuthenticated
+    });
+  });
+  const legacyTransports = /* @__PURE__ */ new Map();
+  const createMCPServer = () => {
+    const server2 = new Server(
+      {
+        name: "drumcode",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    server2.setRequestHandler(ListToolsRequestSchema, async () => {
+      const capabilities = {
+        type: options.clientMode === "full" ? "anthropic" : "unknown",
+        supportsAdvancedToolUse: options.clientMode === "full",
+        supportsDeferredLoading: options.clientMode === "full"
+      };
+      const tools = await runner.getToolList(capabilities);
+      const toolMap = /* @__PURE__ */ new Map();
+      for (const t of [...demoTools, ...arxivTools]) {
+        toolMap.set(t.name, t);
+      }
+      for (const t of tools) {
+        toolMap.set(t.name, t);
+      }
+      const allTools = Array.from(toolMap.values()).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: {
+          type: "object",
+          properties: t.input_schema.properties,
+          required: t.input_schema.required
+        }
+      }));
+      return { tools: allTools };
+    });
+    server2.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const result = await runner.executeTool({
+        name,
+        arguments: args ?? {}
+      });
+      return {
+        content: result.content,
+        isError: result.isError
+      };
+    });
+    return server2;
+  };
+  app.get("/sse", async (req, res) => {
+    console.error("[drumcode] Legacy SSE connection requested");
+    const transport = new SSEServerTransport("/messages", res);
+    const server2 = createMCPServer();
+    await server2.connect(transport);
+    const sessionId = transport.sessionId;
+    legacyTransports.set(sessionId, transport);
+    console.error(`[drumcode] Legacy SSE session started: ${sessionId}`);
+    res.on("close", () => {
+      legacyTransports.delete(sessionId);
+      console.error(`[drumcode] Legacy SSE session closed: ${sessionId}`);
+    });
+  });
+  app.post("/messages", async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId) {
+      res.status(400).json({ error: "Missing sessionId query parameter" });
+      return;
+    }
+    const transport = legacyTransports.get(sessionId);
+    if (!transport) {
+      res.status(404).json({ error: "Session not found. Connect to /sse first." });
+      return;
+    }
+    await transport.handlePostMessage(req, res, req.body);
+  });
+  app.all("/mcp", async (req, res) => {
+    const authHeader = req.headers.authorization;
+    if (options.token && authHeader) {
+      const providedToken = authHeader.replace("Bearer ", "");
+      if (providedToken !== options.token) {
+        console.error("[drumcode] Invalid token in Authorization header");
+        res.status(401).json({ error: "Invalid token" });
+        return;
+      }
+    }
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+      // Stateless mode - no session tracking
+    });
+    const server2 = createMCPServer();
+    await server2.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  });
+  const server = app.listen(options.port, options.host, () => {
+    console.error(`[drumcode] SSE MCP Server started`);
+    console.error(`[drumcode] Listening on http://${options.host}:${options.port}`);
+    console.error(`[drumcode] MCP endpoint: http://${options.host}:${options.port}/mcp`);
+    console.error(`[drumcode] Health check: http://${options.host}:${options.port}/health`);
+  });
+  const shutdown = () => {
+    console.error("[drumcode] Shutting down...");
+    server.close(() => {
+      console.error("[drumcode] Server closed");
+      process.exit(0);
+    });
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+
+// src/types.ts
+import { z } from "zod";
+var runnerOptionsSchema = z.object({
+  token: z.string().optional(),
+  project: z.string().optional(),
+  registryUrl: z.string().url().default("https://api.drumcode.ai"),
+  cacheEnabled: z.boolean().default(true),
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  transport: z.enum(["stdio", "sse"]).default("stdio"),
+  /**
+   * Client mode affects how tools are exposed:
+   * - 'polyfill': Only expose core meta-tools (search + get_schema) - default for generic clients
+   * - 'full': Expose full manifest from registry - for clients that support large tool lists
+   */
+  clientMode: z.enum(["polyfill", "full"]).default("polyfill"),
+  /**
+   * Port for SSE server (only used when transport is 'sse')
+   */
+  port: z.number().default(3001),
+  /**
+   * Host for SSE server (only used when transport is 'sse')
+   */
+  host: z.string().default("0.0.0.0"),
+  /**
+   * Integration base URLs for registry tools (keyed by integration name)
+   */
+  integrationBaseUrls: z.record(z.string()).optional(),
+  /**
+   * Integration headers for registry tools (keyed by integration name)
+   */
+  integrationHeaders: z.record(z.record(z.string())).optional()
+});
+
+// src/cli.ts
+config();
+function parseJsonEnv(value, name) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`Invalid JSON in ${name}`);
+  }
+}
+var program = new Command();
+program.name("drumcode").description("Drumcode MCP Runner - AI-Ready SaaS Infrastructure").version("0.1.0");
+program.command("start").description("Start the Drumcode MCP server").option("-t, --token <token>", "Drumcode API token").option("-p, --project <project>", "Project name").option("-r, --registry <url>", "Registry URL", "https://drumcode-studio.vercel.app/api").option("--no-cache", "Disable caching").option("-l, --log-level <level>", "Log level (debug, info, warn, error)", "info").option("--transport <type>", "Transport type (stdio, sse)", "stdio").option("--port <port>", "Port for SSE server (default: 3001)", "3001").option("--host <host>", "Host for SSE server (default: 0.0.0.0)", "0.0.0.0").option("-m, --mode <mode>", "Client mode: polyfill (meta-tools only) or full (all tools from registry)", "polyfill").action(async (opts) => {
+  try {
+    const integrationBaseUrls = parseJsonEnv(
+      process.env.DRUMCODE_INTEGRATION_BASE_URLS,
+      "DRUMCODE_INTEGRATION_BASE_URLS"
+    );
+    const integrationHeaders = parseJsonEnv(
+      process.env.DRUMCODE_INTEGRATION_HEADERS,
+      "DRUMCODE_INTEGRATION_HEADERS"
+    );
+    const options = runnerOptionsSchema.parse({
+      token: opts.token || process.env.DRUMCODE_TOKEN,
+      project: opts.project || process.env.DRUMCODE_PROJECT,
+      registryUrl: opts.registry || process.env.DRUMCODE_REGISTRY_URL,
+      cacheEnabled: opts.cache !== false,
+      logLevel: opts.logLevel,
+      transport: opts.transport,
+      port: parseInt(opts.port, 10),
+      host: opts.host,
+      clientMode: opts.mode || process.env.DRUMCODE_CLIENT_MODE || "polyfill",
+      integrationBaseUrls,
+      integrationHeaders
+    });
+    console.error("[drumcode] Starting MCP server...");
+    console.error("[drumcode] Registry:", options.registryUrl);
+    console.error("[drumcode] Log level:", options.logLevel);
+    console.error("[drumcode] Transport:", options.transport);
+    console.error("[drumcode] Client mode:", options.clientMode);
+    if (!options.token) {
+      console.error("[drumcode] Warning: No token provided. Running in demo mode.");
+      console.error("[drumcode] Set DRUMCODE_TOKEN or use --token to connect to Registry.");
+    }
+    if (options.clientMode === "full") {
+      console.error("[drumcode] Full manifest mode: All tools from registry will be exposed");
+    } else {
+      console.error("[drumcode] Polyfill mode: Only meta-tools + hardcoded tools will be exposed");
+    }
+    if (options.transport === "sse") {
+      await createSSEServer(options);
+    } else {
+      await createServer(options);
+    }
+  } catch (error) {
+    console.error("[drumcode] Failed to start:", error);
+    process.exit(1);
+  }
+});
+program.command("version").description("Show version information").action(() => {
+  console.log("Drumcode Runner v0.1.0");
+});
+program.parse();

package/dist/index.d.mts

@@ -0,0 +1,192 @@
+import { Tool } from '@drumcode/core';
+import { z } from 'zod';
+
+declare const runnerOptionsSchema: z.ZodObject<{
+    token: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    registryUrl: z.ZodDefault<z.ZodString>;
+    cacheEnabled: z.ZodDefault<z.ZodBoolean>;
+    logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse"]>>;
+    /**
+     * Client mode affects how tools are exposed:
+     * - 'polyfill': Only expose core meta-tools (search + get_schema) - default for generic clients
+     * - 'full': Expose full manifest from registry - for clients that support large tool lists
+     */
+    clientMode: z.ZodDefault<z.ZodEnum<["polyfill", "full"]>>;
+    /**
+     * Port for SSE server (only used when transport is 'sse')
+     */
+    port: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Host for SSE server (only used when transport is 'sse')
+     */
+    host: z.ZodDefault<z.ZodString>;
+    /**
+     * Integration base URLs for registry tools (keyed by integration name)
+     */
+    integrationBaseUrls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * Integration headers for registry tools (keyed by integration name)
+     */
+    integrationHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    registryUrl: string;
+    cacheEnabled: boolean;
+    logLevel: "info" | "debug" | "warn" | "error";
+    transport: "stdio" | "sse";
+    clientMode: "polyfill" | "full";
+    port: number;
+    host: string;
+    token?: string | undefined;
+    project?: string | undefined;
+    integrationBaseUrls?: Record<string, string> | undefined;
+    integrationHeaders?: Record<string, Record<string, string>> | undefined;
+}, {
+    token?: string | undefined;
+    project?: string | undefined;
+    registryUrl?: string | undefined;
+    cacheEnabled?: boolean | undefined;
+    logLevel?: "info" | "debug" | "warn" | "error" | undefined;
+    transport?: "stdio" | "sse" | undefined;
+    clientMode?: "polyfill" | "full" | undefined;
+    port?: number | undefined;
+    host?: string | undefined;
+    integrationBaseUrls?: Record<string, string> | undefined;
+    integrationHeaders?: Record<string, Record<string, string>> | undefined;
+}>;
+type RunnerOptions = z.infer<typeof runnerOptionsSchema>;
+interface ToolCallRequest {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+interface ToolCallResult {
+    content: Array<{
+        type: 'text' | 'image' | 'resource';
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+}
+interface TokenValidationResponse {
+    valid: boolean;
+    project?: {
+        id: string;
+    };
+    token?: {
+        id: string;
+        name: string | null;
+        profileId: string | null;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface AuthenticatedContext {
+    isAuthenticated: boolean;
+    projectId: string | null;
+    tokenId: string | null;
+    tokenName: string | null;
+    profileId: string | null;
+}
+type ClientType = 'anthropic' | 'openai' | 'cursor' | 'langchain' | 'unknown';
+interface ClientCapabilities {
+    type: ClientType;
+    supportsAdvancedToolUse: boolean;
+    supportsDeferredLoading: boolean;
+}
+
+declare class DrumcodeRunner {
+    private options;
+    private toolCache;
+    private skillCache;
+    private manifestCache;
+    private authContext;
+    private authInitialized;
+    constructor(options: RunnerOptions);
+    /**
+     * Initialize authentication by validating the token with the registry
+     * This should be called before processing any requests
+     */
+    initializeAuth(): Promise<AuthenticatedContext>;
+    /**
+     * Get the current authentication context
+     */
+    getAuthContext(): AuthenticatedContext;
+    /**
+     * Check if the runner is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get the list of tools to expose to the client
+     * Uses Polyfill strategy for non-Anthropic clients
+     */
+    getToolList(capabilities: ClientCapabilities): Promise<Tool[]>;
+    /**
+     * Fetch the full tool manifest from the Registry
+     */
+    private getFullManifest;
+    /**
+     * Execute a tool call
+     */
+    executeTool(request: ToolCallRequest): Promise<ToolCallResult>;
+    /**
+     * Handle drumcode_search_tools meta-tool
+     */
+    private handleSearchTools;
+    /**
+     * Handle drumcode_get_tool_schema meta-tool
+     */
+    private handleGetToolSchema;
+    private fetchRegistryToolSchema;
+    /**
+     * Execute a regular (non-meta) tool
+     */
+    private executeRegularTool;
+    private executeRegistryTool;
+    /**
+     * Fetch skill definition from registry
+     */
+    private fetchSkill;
+    /**
+     * Execute a skill (validator or workflow)
+     */
+    private executeSkill;
+    /**
+     * Evaluate a policy rule against context
+     * Simple expression evaluator for rules like "input.query && input.query.length >= 2"
+     */
+    private evaluateRule;
+    /**
+     * Evaluate an argument mapping expression
+     * Supports expressions like "input.query", "input.max_results || 5", "steps.search_results.papers[0].id"
+     */
+    private evaluateMapping;
+    /**
+     * Parse tool result content to extract structured data
+     */
+    private parseToolResult;
+    /**
+     * Execute arXiv tools via the arXiv API
+     */
+    private executeArxivTool;
+    /**
+     * Parse arXiv Atom XML response
+     */
+    private parseArxivResponse;
+    private getIntegrationBaseUrl;
+    private getIntegrationHeaders;
+    private buildToolRequest;
+    private getAuthHeaders;
+    private formatToolSchema;
+    private log;
+}
+
+/**
+ * Create and configure the MCP server
+ */
+declare function createServer(options: RunnerOptions): Promise<void>;
+
+export { type AuthenticatedContext, DrumcodeRunner, type RunnerOptions, type TokenValidationResponse, createServer };