skedyul 0.3.0 → 0.3.2

package/dist/server/handler-helpers.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHandlerEnvelope = parseHandlerEnvelope;
+exports.buildRequestFromRaw = buildRequestFromRaw;
+exports.buildRequestScopedConfig = buildRequestScopedConfig;
+/**
+ * Parses a handler envelope from the request body.
+ * Detects envelope format: { env: {...}, request: {...}, context?: {...} }
+ * Returns the extracted env and request, or null if not an envelope.
+ */
+function parseHandlerEnvelope(parsedBody) {
+    // Check if parsedBody is an object with env and request properties
+    if (typeof parsedBody !== 'object' ||
+        parsedBody === null ||
+        Array.isArray(parsedBody) ||
+        !('env' in parsedBody) ||
+        !('request' in parsedBody)) {
+        return null;
+    }
+    const envelope = parsedBody;
+    // Validate env is an object (not null, not array)
+    if (typeof envelope.env !== 'object' ||
+        envelope.env === null ||
+        Array.isArray(envelope.env)) {
+        return null;
+    }
+    // Validate request is an object (structure validation happens in buildRequestFromRaw)
+    if (typeof envelope.request !== 'object' ||
+        envelope.request === null ||
+        Array.isArray(envelope.request)) {
+        return null;
+    }
+    return {
+        env: envelope.env,
+        request: envelope.request,
+        context: envelope.context,
+    };
+}
+/**
+ * Converts a raw HandlerRawRequest (wire format) to a rich WebhookRequest.
+ * Parses JSON body if content-type is application/json, creates Buffer rawBody.
+ */
+function buildRequestFromRaw(raw) {
+    // Parse the original request body
+    let parsedBody = raw.body;
+    const contentType = raw.headers['content-type'] ?? '';
+    if (contentType.includes('application/json')) {
+        try {
+            parsedBody = raw.body ? JSON.parse(raw.body) : {};
+        }
+        catch {
+            // Keep as string if JSON parsing fails
+            parsedBody = raw.body;
+        }
+    }
+    return {
+        method: raw.method,
+        url: raw.url,
+        path: raw.path,
+        headers: raw.headers,
+        query: raw.query,
+        body: parsedBody,
+        rawBody: raw.body ? Buffer.from(raw.body, 'utf-8') : undefined,
+    };
+}
+/**
+ * Builds request-scoped config by merging env from envelope with process.env fallbacks.
+ * Used for SKEDYUL_API_TOKEN and SKEDYUL_API_URL overrides.
+ */
+function buildRequestScopedConfig(env) {
+    return {
+        baseUrl: env.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? '',
+        apiToken: env.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
+    };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,19 @@
+import type { DedicatedServerInstance, ServerlessServerInstance, SkedyulServerConfig, SkedyulServerInstance, ToolRegistry, WebhookRegistry } from '../types';
+export type { RequestState, CoreMethod, ToolCallArgs } from './types';
+export { normalizeBilling, toJsonSchema, isToolSchemaWithJson, getZodSchema, getJsonSchemaFromToolSchema, parseJsonRecord, parseNumberEnv, mergeRuntimeEnv, readRawRequestBody, parseJSONBody, sendJSON, sendHTML, getDefaultHeaders, createResponse, getListeningPort, } from './utils';
+export { handleCoreMethod } from './core-api-handler';
+export { buildToolMetadata, createRequestState, createCallToolHandler } from './tool-handler';
+export { parseHandlerEnvelope, buildRequestFromRaw, buildRequestScopedConfig } from './handler-helpers';
+export { printStartupLog, padEnd } from './startup-logger';
+export { createDedicatedServerInstance } from './dedicated';
+export { createServerlessInstance } from './serverless';
+export declare function createSkedyulServer(config: SkedyulServerConfig & {
+    computeLayer: 'dedicated';
+}, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): DedicatedServerInstance;
+export declare function createSkedyulServer(config: SkedyulServerConfig & {
+    computeLayer: 'serverless';
+}, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): ServerlessServerInstance;
+export declare function createSkedyulServer(config: SkedyulServerConfig, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): SkedyulServerInstance;
+export declare const server: {
+    create: typeof createSkedyulServer;
+};

package/dist/server/index.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.server = exports.createServerlessInstance = exports.createDedicatedServerInstance = exports.padEnd = exports.printStartupLog = exports.buildRequestScopedConfig = exports.buildRequestFromRaw = exports.parseHandlerEnvelope = exports.createCallToolHandler = exports.createRequestState = exports.buildToolMetadata = exports.handleCoreMethod = exports.getListeningPort = exports.createResponse = exports.getDefaultHeaders = exports.sendHTML = exports.sendJSON = exports.parseJSONBody = exports.readRawRequestBody = exports.mergeRuntimeEnv = exports.parseNumberEnv = exports.parseJsonRecord = exports.getJsonSchemaFromToolSchema = exports.getZodSchema = exports.isToolSchemaWithJson = exports.toJsonSchema = exports.normalizeBilling = void 0;
+exports.createSkedyulServer = createSkedyulServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const z = __importStar(require("zod"));
+const service_1 = require("../core/service");
+const tool_handler_1 = require("./tool-handler");
+const dedicated_1 = require("./dedicated");
+const serverless_1 = require("./serverless");
+const utils_1 = require("./utils");
+// Re-export utilities
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "normalizeBilling", { enumerable: true, get: function () { return utils_2.normalizeBilling; } });
+Object.defineProperty(exports, "toJsonSchema", { enumerable: true, get: function () { return utils_2.toJsonSchema; } });
+Object.defineProperty(exports, "isToolSchemaWithJson", { enumerable: true, get: function () { return utils_2.isToolSchemaWithJson; } });
+Object.defineProperty(exports, "getZodSchema", { enumerable: true, get: function () { return utils_2.getZodSchema; } });
+Object.defineProperty(exports, "getJsonSchemaFromToolSchema", { enumerable: true, get: function () { return utils_2.getJsonSchemaFromToolSchema; } });
+Object.defineProperty(exports, "parseJsonRecord", { enumerable: true, get: function () { return utils_2.parseJsonRecord; } });
+Object.defineProperty(exports, "parseNumberEnv", { enumerable: true, get: function () { return utils_2.parseNumberEnv; } });
+Object.defineProperty(exports, "mergeRuntimeEnv", { enumerable: true, get: function () { return utils_2.mergeRuntimeEnv; } });
+Object.defineProperty(exports, "readRawRequestBody", { enumerable: true, get: function () { return utils_2.readRawRequestBody; } });
+Object.defineProperty(exports, "parseJSONBody", { enumerable: true, get: function () { return utils_2.parseJSONBody; } });
+Object.defineProperty(exports, "sendJSON", { enumerable: true, get: function () { return utils_2.sendJSON; } });
+Object.defineProperty(exports, "sendHTML", { enumerable: true, get: function () { return utils_2.sendHTML; } });
+Object.defineProperty(exports, "getDefaultHeaders", { enumerable: true, get: function () { return utils_2.getDefaultHeaders; } });
+Object.defineProperty(exports, "createResponse", { enumerable: true, get: function () { return utils_2.createResponse; } });
+Object.defineProperty(exports, "getListeningPort", { enumerable: true, get: function () { return utils_2.getListeningPort; } });
+// Re-export handlers
+var core_api_handler_1 = require("./core-api-handler");
+Object.defineProperty(exports, "handleCoreMethod", { enumerable: true, get: function () { return core_api_handler_1.handleCoreMethod; } });
+var tool_handler_2 = require("./tool-handler");
+Object.defineProperty(exports, "buildToolMetadata", { enumerable: true, get: function () { return tool_handler_2.buildToolMetadata; } });
+Object.defineProperty(exports, "createRequestState", { enumerable: true, get: function () { return tool_handler_2.createRequestState; } });
+Object.defineProperty(exports, "createCallToolHandler", { enumerable: true, get: function () { return tool_handler_2.createCallToolHandler; } });
+var handler_helpers_1 = require("./handler-helpers");
+Object.defineProperty(exports, "parseHandlerEnvelope", { enumerable: true, get: function () { return handler_helpers_1.parseHandlerEnvelope; } });
+Object.defineProperty(exports, "buildRequestFromRaw", { enumerable: true, get: function () { return handler_helpers_1.buildRequestFromRaw; } });
+Object.defineProperty(exports, "buildRequestScopedConfig", { enumerable: true, get: function () { return handler_helpers_1.buildRequestScopedConfig; } });
+var startup_logger_1 = require("./startup-logger");
+Object.defineProperty(exports, "printStartupLog", { enumerable: true, get: function () { return startup_logger_1.printStartupLog; } });
+Object.defineProperty(exports, "padEnd", { enumerable: true, get: function () { return startup_logger_1.padEnd; } });
+var dedicated_2 = require("./dedicated");
+Object.defineProperty(exports, "createDedicatedServerInstance", { enumerable: true, get: function () { return dedicated_2.createDedicatedServerInstance; } });
+var serverless_2 = require("./serverless");
+Object.defineProperty(exports, "createServerlessInstance", { enumerable: true, get: function () { return serverless_2.createServerlessInstance; } });
+function createSkedyulServer(config, registry, webhookRegistry) {
+    (0, utils_1.mergeRuntimeEnv)();
+    if (config.coreApi?.service) {
+        service_1.coreApiService.register(config.coreApi.service);
+        if (config.coreApi.webhookHandler) {
+            service_1.coreApiService.setWebhookHandler(config.coreApi.webhookHandler);
+        }
+    }
+    const tools = (0, tool_handler_1.buildToolMetadata)(registry);
+    const toolNames = Object.values(registry).map((tool) => tool.name);
+    const runtimeLabel = config.computeLayer;
+    const maxRequests = config.maxRequests ??
+        (0, utils_1.parseNumberEnv)(process.env.MCP_MAX_REQUESTS) ??
+        null;
+    const ttlExtendSeconds = config.ttlExtendSeconds ??
+        (0, utils_1.parseNumberEnv)(process.env.MCP_TTL_EXTEND) ??
+        3600;
+    const state = (0, tool_handler_1.createRequestState)(maxRequests, ttlExtendSeconds, runtimeLabel, toolNames);
+    const mcpServer = new mcp_js_1.McpServer({
+        name: config.metadata.name,
+        version: config.metadata.version,
+    });
+    const dedicatedShutdown = () => {
+        // eslint-disable-next-line no-console
+        console.log('Max requests reached, shutting down...');
+        setTimeout(() => process.exit(0), 1000);
+    };
+    const callTool = (0, tool_handler_1.createCallToolHandler)(registry, state, config.computeLayer === 'dedicated' ? dedicatedShutdown : undefined);
+    // Register all tools from the registry
+    for (const [toolKey, tool] of Object.entries(registry)) {
+        // Use the tool's name or fall back to the registry key
+        const toolName = tool.name || toolKey;
+        const toolDisplayName = tool.label || toolName;
+        const inputZodSchema = (0, utils_1.getZodSchema)(tool.inputSchema);
+        const outputZodSchema = (0, utils_1.getZodSchema)(tool.outputSchema);
+        // Wrap the input schema to accept Skedyul format: { inputs: {...}, env: {...} }
+        // This allows the MCP SDK to pass through the wrapper without stripping fields
+        const wrappedInputSchema = z.object({
+            inputs: inputZodSchema ?? z.record(z.string(), z.unknown()).optional(),
+            env: z.record(z.string(), z.string()).optional(),
+        }).passthrough();
+        mcpServer.registerTool(toolName, {
+            title: toolDisplayName,
+            description: tool.description,
+            inputSchema: wrappedInputSchema,
+            outputSchema: outputZodSchema,
+        }, async (args) => {
+            // Args are in Skedyul format: { inputs: {...}, context: {...}, env: {...} }
+            const rawArgs = args;
+            const toolInputs = (rawArgs.inputs ?? {});
+            const toolContext = rawArgs.context;
+            const toolEnv = rawArgs.env;
+            // Validate inputs if schema exists
+            let validatedInputs = toolInputs;
+            if (inputZodSchema) {
+                try {
+                    validatedInputs = inputZodSchema.parse(toolInputs);
+                }
+                catch (error) {
+                    console.error(`[registerTool] Input validation failed for tool ${toolName}:`, error);
+                    // Return error response instead of throwing
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: `Input validation failed: ${error instanceof Error ? error.message : String(error)}`,
+                                }),
+                            },
+                        ],
+                        structuredContent: {
+                            error: `Input validation failed: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                        isError: true,
+                        billing: { credits: 0 },
+                    };
+                }
+            }
+            const result = await callTool(toolKey, {
+                inputs: validatedInputs,
+                context: toolContext,
+                env: toolEnv,
+            });
+            // Handle error case
+            if (result.error) {
+                const errorOutput = { error: result.error };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorOutput) }],
+                    structuredContent: errorOutput,
+                    isError: true,
+                    billing: result.billing,
+                };
+            }
+            // Transform internal format to MCP protocol format
+            // Note: effect is embedded in structuredContent because the MCP SDK
+            // transport strips custom top-level fields in dedicated mode
+            const outputData = result.output;
+            const structuredContent = outputData
+                ? { ...outputData, __effect: result.effect }
+                : result.effect
+                    ? { __effect: result.effect }
+                    : undefined;
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.output) }],
+                structuredContent,
+                billing: result.billing,
+            };
+        });
+    }
+    if (config.computeLayer === 'dedicated') {
+        return (0, dedicated_1.createDedicatedServerInstance)(config, tools, callTool, state, mcpServer, webhookRegistry);
+    }
+    return (0, serverless_1.createServerlessInstance)(config, tools, callTool, state, mcpServer, registry, webhookRegistry);
+}
+exports.server = {
+    create: createSkedyulServer,
+};

package/dist/server/serverless.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SkedyulServerConfig, SkedyulServerInstance, ToolCallResponse, ToolMetadata, ToolRegistry, WebhookRegistry } from '../types';
+import type { RequestState } from './types';
+/**
+ * Creates a serverless (Lambda-style) server instance
+ */
+export declare function createServerlessInstance(config: SkedyulServerConfig, tools: ToolMetadata[], callTool: (nameRaw: unknown, argsRaw: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): SkedyulServerInstance;