skedyul 0.3.0 → 0.3.2

package/dist/server/dedicated.js

@@ -0,0 +1,610 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDedicatedServerInstance = createDedicatedServerInstance;
+const http_1 = __importDefault(require("http"));
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const service_1 = require("../core/service");
+const client_1 = require("../core/client");
+const errors_1 = require("../errors");
+const core_api_handler_1 = require("./core-api-handler");
+const handler_helpers_1 = require("./handler-helpers");
+const startup_logger_1 = require("./startup-logger");
+const utils_1 = require("./utils");
+/**
+ * Creates a dedicated (long-running HTTP) server instance
+ */
+function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, webhookRegistry) {
+    const port = (0, utils_1.getListeningPort)(config);
+    const httpServer = http_1.default.createServer(async (req, res) => {
+        function sendCoreResult(result) {
+            (0, utils_1.sendJSON)(res, result.status, result.payload);
+        }
+        try {
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const pathname = url.pathname;
+            if (pathname === '/health' && req.method === 'GET') {
+                (0, utils_1.sendJSON)(res, 200, state.getHealthStatus());
+                return;
+            }
+            // Handle webhook requests: /webhooks/{handle}
+            if (pathname.startsWith('/webhooks/') && webhookRegistry) {
+                const handle = pathname.slice('/webhooks/'.length);
+                const webhookDef = webhookRegistry[handle];
+                if (!webhookDef) {
+                    (0, utils_1.sendJSON)(res, 404, { error: `Webhook handler '${handle}' not found` });
+                    return;
+                }
+                // Check if HTTP method is allowed
+                const allowedMethods = webhookDef.methods ?? ['POST'];
+                if (!allowedMethods.includes(req.method)) {
+                    (0, utils_1.sendJSON)(res, 405, { error: `Method ${req.method} not allowed` });
+                    return;
+                }
+                // Read raw request body
+                let rawBody;
+                try {
+                    rawBody = await (0, utils_1.readRawRequestBody)(req);
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, { error: 'Failed to read request body' });
+                    return;
+                }
+                // Parse body based on content type
+                let parsedBody;
+                const contentType = req.headers['content-type'] ?? '';
+                if (contentType.includes('application/json')) {
+                    try {
+                        parsedBody = rawBody ? JSON.parse(rawBody) : {};
+                    }
+                    catch {
+                        parsedBody = rawBody;
+                    }
+                }
+                else {
+                    parsedBody = rawBody;
+                }
+                // Check if this is an envelope format from the platform
+                // Envelope format: { env: {...}, request: {...}, context: {...} }
+                const envelope = (0, handler_helpers_1.parseHandlerEnvelope)(parsedBody);
+                let webhookRequest;
+                let webhookContext;
+                let requestEnv = {};
+                if (envelope && 'context' in envelope && envelope.context) {
+                    // Platform envelope format - use shared helpers
+                    const context = envelope.context;
+                    requestEnv = envelope.env;
+                    // Convert raw request to rich request using shared helper
+                    webhookRequest = (0, handler_helpers_1.buildRequestFromRaw)(envelope.request);
+                    const envVars = { ...process.env, ...envelope.env };
+                    const app = context.app;
+                    // Build webhook context based on whether we have installation context
+                    if (context.appInstallationId && context.workplace) {
+                        // Runtime webhook context
+                        webhookContext = {
+                            env: envVars,
+                            app,
+                            appInstallationId: context.appInstallationId,
+                            workplace: context.workplace,
+                            registration: context.registration ?? {},
+                        };
+                    }
+                    else {
+                        // Provision webhook context
+                        webhookContext = {
+                            env: envVars,
+                            app,
+                        };
+                    }
+                }
+                else {
+                    // Direct request format (legacy or direct calls) - requires app info from headers or fail
+                    const appId = req.headers['x-skedyul-app-id'];
+                    const appVersionId = req.headers['x-skedyul-app-version-id'];
+                    if (!appId || !appVersionId) {
+                        throw new Error('Missing app info in webhook request (x-skedyul-app-id and x-skedyul-app-version-id headers required)');
+                    }
+                    webhookRequest = {
+                        method: req.method ?? 'POST',
+                        url: url.toString(),
+                        path: pathname,
+                        headers: req.headers,
+                        query: Object.fromEntries(url.searchParams.entries()),
+                        body: parsedBody,
+                        rawBody: rawBody ? Buffer.from(rawBody, 'utf-8') : undefined,
+                    };
+                    // Direct calls are provision-level (no installation context)
+                    webhookContext = {
+                        env: process.env,
+                        app: { id: appId, versionId: appVersionId },
+                    };
+                }
+                // Temporarily inject env into process.env for skedyul client to use
+                // (same pattern as tool handler)
+                const originalEnv = { ...process.env };
+                Object.assign(process.env, requestEnv);
+                // Build request-scoped config for the skedyul client
+                // This uses AsyncLocalStorage to override the global config (same pattern as tools)
+                const requestConfig = (0, handler_helpers_1.buildRequestScopedConfig)(requestEnv);
+                // Invoke the handler with request-scoped config
+                let webhookResponse;
+                try {
+                    webhookResponse = await (0, client_1.runWithConfig)(requestConfig, async () => {
+                        return await webhookDef.handler(webhookRequest, webhookContext);
+                    });
+                }
+                catch (err) {
+                    console.error(`Webhook handler '${handle}' error:`, err);
+                    (0, utils_1.sendJSON)(res, 500, { error: 'Webhook handler error' });
+                    return;
+                }
+                finally {
+                    // Restore original env
+                    process.env = originalEnv;
+                }
+                // Send response
+                const status = webhookResponse.status ?? 200;
+                const responseHeaders = {
+                    ...webhookResponse.headers,
+                };
+                // Default to JSON content type if not specified
+                if (!responseHeaders['Content-Type'] && !responseHeaders['content-type']) {
+                    responseHeaders['Content-Type'] = 'application/json';
+                }
+                res.writeHead(status, responseHeaders);
+                if (webhookResponse.body !== undefined) {
+                    if (typeof webhookResponse.body === 'string') {
+                        res.end(webhookResponse.body);
+                    }
+                    else {
+                        res.end(JSON.stringify(webhookResponse.body));
+                    }
+                }
+                else {
+                    res.end();
+                }
+                return;
+            }
+            if (pathname === '/estimate' && req.method === 'POST') {
+                let estimateBody;
+                try {
+                    estimateBody = (await (0, utils_1.parseJSONBody)(req));
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: {
+                            code: -32700,
+                            message: 'Parse error',
+                        },
+                    });
+                    return;
+                }
+                try {
+                    const estimateResponse = await callTool(estimateBody.name, {
+                        inputs: estimateBody.inputs,
+                        estimate: true,
+                    });
+                    (0, utils_1.sendJSON)(res, 200, {
+                        billing: estimateResponse.billing ?? { credits: 0 },
+                    });
+                }
+                catch (err) {
+                    (0, utils_1.sendJSON)(res, 500, {
+                        error: {
+                            code: -32603,
+                            message: err instanceof Error ? err.message : String(err ?? ''),
+                        },
+                    });
+                }
+                return;
+            }
+            // Handle /oauth_callback endpoint for OAuth callbacks (called by Temporal workflow)
+            if (pathname === '/oauth_callback' && req.method === 'POST') {
+                if (!config.hooks?.oauth_callback) {
+                    (0, utils_1.sendJSON)(res, 404, { error: 'OAuth callback handler not configured' });
+                    return;
+                }
+                let parsedBody;
+                try {
+                    parsedBody = await (0, utils_1.parseJSONBody)(req);
+                }
+                catch (err) {
+                    console.error('[OAuth Callback] Failed to parse JSON body:', err);
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32700, message: 'Parse error' },
+                    });
+                    return;
+                }
+                // Parse envelope using shared helper
+                const envelope = (0, handler_helpers_1.parseHandlerEnvelope)(parsedBody);
+                if (!envelope) {
+                    console.error('[OAuth Callback] Failed to parse envelope. Body:', JSON.stringify(parsedBody, null, 2));
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32602, message: 'Missing envelope format: expected { env, request }' },
+                    });
+                    return;
+                }
+                // Convert raw request to rich request using shared helper
+                const oauthRequest = (0, handler_helpers_1.buildRequestFromRaw)(envelope.request);
+                // Build request-scoped config using shared helper
+                const oauthCallbackRequestConfig = (0, handler_helpers_1.buildRequestScopedConfig)(envelope.env);
+                const oauthCallbackContext = {
+                    request: oauthRequest,
+                };
+                try {
+                    const oauthCallbackHook = config.hooks.oauth_callback;
+                    const oauthCallbackHandler = typeof oauthCallbackHook === 'function'
+                        ? oauthCallbackHook
+                        : oauthCallbackHook.handler;
+                    const result = await (0, client_1.runWithConfig)(oauthCallbackRequestConfig, async () => {
+                        return await oauthCallbackHandler(oauthCallbackContext);
+                    });
+                    (0, utils_1.sendJSON)(res, 200, {
+                        appInstallationId: result.appInstallationId,
+                        env: result.env ?? {},
+                    });
+                }
+                catch (err) {
+                    const errorMessage = err instanceof Error ? err.message : String(err ?? 'Unknown error');
+                    (0, utils_1.sendJSON)(res, 500, {
+                        error: {
+                            code: -32603,
+                            message: errorMessage,
+                        },
+                    });
+                }
+                return;
+            }
+            // Handle /install endpoint for install handlers
+            if (pathname === '/install' && req.method === 'POST') {
+                if (!config.hooks?.install) {
+                    (0, utils_1.sendJSON)(res, 404, { error: 'Install handler not configured' });
+                    return;
+                }
+                let installBody;
+                try {
+                    installBody = (await (0, utils_1.parseJSONBody)(req));
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32700, message: 'Parse error' },
+                    });
+                    return;
+                }
+                if (!installBody.context?.appInstallationId || !installBody.context?.workplace) {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32602, message: 'Missing context (appInstallationId and workplace required)' },
+                    });
+                    return;
+                }
+                const installContext = {
+                    env: installBody.env ?? {},
+                    workplace: installBody.context.workplace,
+                    appInstallationId: installBody.context.appInstallationId,
+                    app: installBody.context.app,
+                };
+                // Build request-scoped config for SDK access
+                // Use env from request body (contains generated token from workflow)
+                const installRequestConfig = {
+                    baseUrl: installBody.env?.SKEDYUL_API_URL ??
+                        process.env.SKEDYUL_API_URL ??
+                        '',
+                    apiToken: installBody.env?.SKEDYUL_API_TOKEN ??
+                        process.env.SKEDYUL_API_TOKEN ??
+                        '',
+                };
+                try {
+                    const installHook = config.hooks.install;
+                    const installHandler = typeof installHook === 'function'
+                        ? installHook
+                        : installHook.handler;
+                    const result = await (0, client_1.runWithConfig)(installRequestConfig, async () => {
+                        return await installHandler(installContext);
+                    });
+                    (0, utils_1.sendJSON)(res, 200, {
+                        env: result.env ?? {},
+                        redirect: result.redirect,
+                    });
+                }
+                catch (err) {
+                    // Check for typed install errors
+                    if (err instanceof errors_1.InstallError) {
+                        (0, utils_1.sendJSON)(res, 400, {
+                            error: {
+                                code: err.code,
+                                message: err.message,
+                                field: err.field,
+                            },
+                        });
+                    }
+                    else {
+                        (0, utils_1.sendJSON)(res, 500, {
+                            error: {
+                                code: -32603,
+                                message: err instanceof Error ? err.message : String(err ?? ''),
+                            },
+                        });
+                    }
+                }
+                return;
+            }
+            // Handle /uninstall endpoint for uninstall handlers
+            if (pathname === '/uninstall' && req.method === 'POST') {
+                if (!config.hooks?.uninstall) {
+                    (0, utils_1.sendJSON)(res, 404, { error: 'Uninstall handler not configured' });
+                    return;
+                }
+                let uninstallBody;
+                try {
+                    uninstallBody = (await (0, utils_1.parseJSONBody)(req));
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32700, message: 'Parse error' },
+                    });
+                    return;
+                }
+                if (!uninstallBody.context?.appInstallationId ||
+                    !uninstallBody.context?.workplace ||
+                    !uninstallBody.context?.app) {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: {
+                            code: -32602,
+                            message: 'Missing context (appInstallationId, workplace and app required)',
+                        },
+                    });
+                    return;
+                }
+                const uninstallContext = {
+                    env: uninstallBody.env ?? {},
+                    workplace: uninstallBody.context.workplace,
+                    appInstallationId: uninstallBody.context.appInstallationId,
+                    app: uninstallBody.context.app,
+                };
+                const uninstallRequestConfig = {
+                    baseUrl: uninstallBody.env?.SKEDYUL_API_URL ??
+                        process.env.SKEDYUL_API_URL ??
+                        '',
+                    apiToken: uninstallBody.env?.SKEDYUL_API_TOKEN ??
+                        process.env.SKEDYUL_API_TOKEN ??
+                        '',
+                };
+                try {
+                    const uninstallHook = config.hooks.uninstall;
+                    const uninstallHandlerFn = typeof uninstallHook === 'function' ? uninstallHook : uninstallHook.handler;
+                    const result = await (0, client_1.runWithConfig)(uninstallRequestConfig, async () => {
+                        return await uninstallHandlerFn(uninstallContext);
+                    });
+                    (0, utils_1.sendJSON)(res, 200, {
+                        cleanedWebhookIds: result.cleanedWebhookIds ?? [],
+                    });
+                }
+                catch (err) {
+                    (0, utils_1.sendJSON)(res, 500, {
+                        error: {
+                            code: -32603,
+                            message: err instanceof Error ? err.message : String(err ?? ''),
+                        },
+                    });
+                }
+                return;
+            }
+            // Handle /provision endpoint for provision handlers
+            if (pathname === '/provision' && req.method === 'POST') {
+                if (!config.hooks?.provision) {
+                    (0, utils_1.sendJSON)(res, 404, { error: 'Provision handler not configured' });
+                    return;
+                }
+                let provisionBody;
+                try {
+                    provisionBody = (await (0, utils_1.parseJSONBody)(req));
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32700, message: 'Parse error' },
+                    });
+                    return;
+                }
+                if (!provisionBody.context?.app) {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: { code: -32602, message: 'Missing context (app required)' },
+                    });
+                    return;
+                }
+                // SECURITY: Merge process.env (baked-in secrets) with request env (API token).
+                // This ensures secrets like MAILGUN_API_KEY come from the container,
+                // while runtime values like SKEDYUL_API_TOKEN come from the request.
+                const mergedEnv = {};
+                for (const [key, value] of Object.entries(process.env)) {
+                    if (value !== undefined) {
+                        mergedEnv[key] = value;
+                    }
+                }
+                // Request env overrides process.env (e.g., for SKEDYUL_API_TOKEN)
+                Object.assign(mergedEnv, provisionBody.env ?? {});
+                const provisionContext = {
+                    env: mergedEnv,
+                    app: provisionBody.context.app,
+                };
+                // Build request-scoped config for SDK access
+                // Use merged env for consistency
+                const provisionRequestConfig = {
+                    baseUrl: mergedEnv.SKEDYUL_API_URL ?? '',
+                    apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? '',
+                };
+                try {
+                    const provisionHook = config.hooks.provision;
+                    const provisionHandler = typeof provisionHook === 'function'
+                        ? provisionHook
+                        : provisionHook.handler;
+                    const result = await (0, client_1.runWithConfig)(provisionRequestConfig, async () => {
+                        return await provisionHandler(provisionContext);
+                    });
+                    (0, utils_1.sendJSON)(res, 200, result);
+                }
+                catch (err) {
+                    (0, utils_1.sendJSON)(res, 500, {
+                        error: {
+                            code: -32603,
+                            message: err instanceof Error ? err.message : String(err ?? ''),
+                        },
+                    });
+                }
+                return;
+            }
+            if (pathname === '/core' && req.method === 'POST') {
+                let coreBody;
+                try {
+                    coreBody = (await (0, utils_1.parseJSONBody)(req));
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: {
+                            code: -32700,
+                            message: 'Parse error',
+                        },
+                    });
+                    return;
+                }
+                if (!coreBody?.method) {
+                    (0, utils_1.sendJSON)(res, 400, {
+                        error: {
+                            code: -32602,
+                            message: 'Missing method',
+                        },
+                    });
+                    return;
+                }
+                const method = coreBody.method;
+                const result = await (0, core_api_handler_1.handleCoreMethod)(method, coreBody.params);
+                sendCoreResult(result);
+                return;
+            }
+            if (pathname === '/core/webhook' && req.method === 'POST') {
+                let rawWebhookBody;
+                try {
+                    rawWebhookBody = await (0, utils_1.readRawRequestBody)(req);
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, { status: 'parse-error' });
+                    return;
+                }
+                let webhookBody;
+                try {
+                    webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
+                }
+                catch {
+                    (0, utils_1.sendJSON)(res, 400, { status: 'parse-error' });
+                    return;
+                }
+                const normalizedHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, value]) => [
+                    key,
+                    typeof value === 'string' ? value : value?.[0] ?? '',
+                ]));
+                const coreWebhookRequest = {
+                    method: req.method ?? 'POST',
+                    headers: normalizedHeaders,
+                    body: webhookBody,
+                    query: Object.fromEntries(url.searchParams.entries()),
+                    url: url.toString(),
+                    path: url.pathname,
+                    rawBody: rawWebhookBody
+                        ? Buffer.from(rawWebhookBody, 'utf-8')
+                        : undefined,
+                };
+                const webhookResponse = await service_1.coreApiService.dispatchWebhook(coreWebhookRequest);
+                res.writeHead(webhookResponse.status, {
+                    'Content-Type': 'application/json',
+                });
+                res.end(JSON.stringify(webhookResponse.body ?? {}));
+                return;
+            }
+            if (pathname === '/mcp' && req.method === 'POST') {
+                try {
+                    const body = await (0, utils_1.parseJSONBody)(req);
+                    // Handle tools/list directly to include custom metadata (timeout, displayName, outputSchema)
+                    // The MCP SDK only returns standard fields, so we intercept and return the full metadata
+                    if (body?.method === 'tools/list') {
+                        (0, utils_1.sendJSON)(res, 200, {
+                            jsonrpc: '2.0',
+                            id: body.id ?? null,
+                            result: { tools },
+                        });
+                        return;
+                    }
+                    // Handle webhooks/list before passing to MCP SDK transport
+                    if (body?.method === 'webhooks/list') {
+                        const webhooks = webhookRegistry
+                            ? Object.values(webhookRegistry).map((w) => ({
+                                name: w.name,
+                                description: w.description,
+                                methods: w.methods ?? ['POST'],
+                                type: w.type ?? 'WEBHOOK',
+                            }))
+                            : [];
+                        (0, utils_1.sendJSON)(res, 200, {
+                            jsonrpc: '2.0',
+                            id: body.id ?? null,
+                            result: { webhooks },
+                        });
+                        return;
+                    }
+                    // Pass to MCP SDK transport for standard MCP methods (tools/call, etc.)
+                    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                        sessionIdGenerator: undefined,
+                        enableJsonResponse: true,
+                    });
+                    res.on('close', () => {
+                        transport.close();
+                    });
+                    await mcpServer.connect(transport);
+                    await transport.handleRequest(req, res, body);
+                }
+                catch (err) {
+                    (0, utils_1.sendJSON)(res, 500, {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32603,
+                            message: err instanceof Error ? err.message : String(err ?? ''),
+                        },
+                    });
+                }
+                return;
+            }
+            (0, utils_1.sendJSON)(res, 404, {
+                jsonrpc: '2.0',
+                id: null,
+                error: {
+                    code: -32601,
+                    message: 'Not Found',
+                },
+            });
+        }
+        catch (err) {
+            (0, utils_1.sendJSON)(res, 500, {
+                jsonrpc: '2.0',
+                id: null,
+                error: {
+                    code: -32603,
+                    message: err instanceof Error ? err.message : String(err ?? ''),
+                },
+            });
+        }
+    });
+    return {
+        async listen(listenPort) {
+            const finalPort = listenPort ?? port;
+            return new Promise((resolve, reject) => {
+                httpServer.listen(finalPort, () => {
+                    (0, startup_logger_1.printStartupLog)(config, tools, webhookRegistry, finalPort);
+                    resolve();
+                });
+                httpServer.once('error', reject);
+            });
+        },
+        getHealthStatus: () => state.getHealthStatus(),
+    };
+}

package/dist/server/handler-helpers.d.ts

@@ -0,0 +1,24 @@
+import type { HandlerRawRequest, WebhookRequest } from '../types';
+/**
+ * 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.
+ */
+export declare function parseHandlerEnvelope(parsedBody: unknown): {
+    env: Record<string, string>;
+    request: HandlerRawRequest;
+    context?: unknown;
+} | null;
+/**
+ * Converts a raw HandlerRawRequest (wire format) to a rich WebhookRequest.
+ * Parses JSON body if content-type is application/json, creates Buffer rawBody.
+ */
+export declare function buildRequestFromRaw(raw: HandlerRawRequest): WebhookRequest;
+/**
+ * Builds request-scoped config by merging env from envelope with process.env fallbacks.
+ * Used for SKEDYUL_API_TOKEN and SKEDYUL_API_URL overrides.
+ */
+export declare function buildRequestScopedConfig(env: Record<string, string>): {
+    baseUrl: string;
+    apiToken: string;
+};