skedyul 0.2.151 → 0.2.153

package/dist/.build-stamp

@@ -1 +1 @@
-1770695243488
+1770699014045

package/dist/server.js

@@ -690,6 +690,79 @@ function createSkedyulServer(config, registry, webhookRegistry) {
     }
     return createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry);
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared Handler Helpers (used by both webhooks and OAuth callbacks)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 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 ?? '',
+    };
+}
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, webhookRegistry) {
     const port = getListeningPort(config);
     const httpServer = http_1.default.createServer(async (req, res) => {
@@ -742,49 +815,27 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                 }
                 // Check if this is an envelope format from the platform
                 // Envelope format: { env: {...}, request: {...}, context: {...} }
-                const isEnvelope = (typeof parsedBody === 'object' &&
-                    parsedBody !== null &&
-                    'env' in parsedBody &&
-                    'request' in parsedBody &&
-                    'context' in parsedBody);
+                const envelope = parseHandlerEnvelope(parsedBody);
                 let webhookRequest;
                 let webhookContext;
                 let requestEnv = {};
-                if (isEnvelope) {
-                    // Platform envelope format - extract env, request, and context
-                    const envelope = parsedBody;
-                    requestEnv = envelope.env ?? {};
-                    // Parse the original request body
-                    let originalParsedBody = envelope.request.body;
-                    const originalContentType = envelope.request.headers['content-type'] ?? '';
-                    if (originalContentType.includes('application/json')) {
-                        try {
-                            originalParsedBody = envelope.request.body ? JSON.parse(envelope.request.body) : {};
-                        }
-                        catch {
-                            // Keep as string if JSON parsing fails
-                        }
-                    }
-                    webhookRequest = {
-                        method: envelope.request.method,
-                        url: envelope.request.url,
-                        path: envelope.request.path,
-                        headers: envelope.request.headers,
-                        query: envelope.request.query,
-                        body: originalParsedBody,
-                        rawBody: envelope.request.body ? Buffer.from(envelope.request.body, 'utf-8') : undefined,
-                    };
-                    const envVars = { ...process.env, ...requestEnv };
-                    const app = envelope.context.app;
+                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 = buildRequestFromRaw(envelope.request);
+                    const envVars = { ...process.env, ...envelope.env };
+                    const app = context.app;
                     // Build webhook context based on whether we have installation context
-                    if (envelope.context.appInstallationId && envelope.context.workplace) {
+                    if (context.appInstallationId && context.workplace) {
                         // Runtime webhook context
                         webhookContext = {
                             env: envVars,
                             app,
-                            appInstallationId: envelope.context.appInstallationId,
-                            workplace: envelope.context.workplace,
-                            registration: envelope.context.registration ?? {},
+                            appInstallationId: context.appInstallationId,
+                            workplace: context.workplace,
+                            registration: context.registration ?? {},
                         };
                     }
                     else {
@@ -823,10 +874,7 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                 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 = {
-                    baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? '',
-                    apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
-                };
+                const requestConfig = buildRequestScopedConfig(requestEnv);
                 // Invoke the handler with request-scoped config
                 let webhookResponse;
                 try {
@@ -905,9 +953,9 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                     sendJSON(res, 404, { error: 'OAuth callback handler not configured' });
                     return;
                 }
-                let oauthCallbackBody = {};
+                let parsedBody;
                 try {
-                    oauthCallbackBody = (await parseJSONBody(req));
+                    parsedBody = await parseJSONBody(req);
                 }
                 catch {
                     sendJSON(res, 400, {
@@ -915,20 +963,20 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                     });
                     return;
                 }
-                if (!oauthCallbackBody.query) {
+                // Parse envelope using shared helper
+                const envelope = parseHandlerEnvelope(parsedBody);
+                if (!envelope) {
                     sendJSON(res, 400, {
-                        error: { code: -32602, message: 'Missing query parameter' },
+                        error: { code: -32602, message: 'Missing envelope format: expected { env, request }' },
                     });
                     return;
                 }
-                // Build request-scoped config for SDK access
-                // Prefer fresh token from request body (generated by workflow), fall back to baked-in env
-                const oauthCallbackRequestConfig = {
-                    baseUrl: oauthCallbackBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? '',
-                    apiToken: oauthCallbackBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
-                };
+                // Convert raw request to rich request using shared helper
+                const oauthRequest = buildRequestFromRaw(envelope.request);
+                // Build request-scoped config using shared helper
+                const oauthCallbackRequestConfig = buildRequestScopedConfig(envelope.env);
                 const oauthCallbackContext = {
-                    query: oauthCallbackBody.query,
+                    request: oauthRequest,
                 };
                 try {
                     const oauthCallbackHook = config.hooks.oauth_callback;
@@ -1576,24 +1624,24 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                     if (!config.hooks?.oauth_callback) {
                         return createResponse(404, { error: 'OAuth callback handler not configured' }, headers);
                     }
-                    let oauthCallbackBody = {};
+                    let parsedBody;
                     try {
-                        oauthCallbackBody = event.body ? JSON.parse(event.body) : {};
+                        parsedBody = event.body ? JSON.parse(event.body) : {};
                     }
                     catch {
                         return createResponse(400, { error: { code: -32700, message: 'Parse error' } }, headers);
                     }
-                    if (!oauthCallbackBody.query) {
-                        return createResponse(400, { error: { code: -32602, message: 'Missing query parameter' } }, headers);
+                    // Parse envelope using shared helper
+                    const envelope = parseHandlerEnvelope(parsedBody);
+                    if (!envelope) {
+                        return createResponse(400, { error: { code: -32602, message: 'Missing envelope format: expected { env, request }' } }, headers);
                     }
-                    // Build request-scoped config for SDK access
-                    // Prefer fresh token from request body (generated by workflow), fall back to baked-in env
-                    const oauthCallbackRequestConfig = {
-                        baseUrl: oauthCallbackBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? '',
-                        apiToken: oauthCallbackBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
-                    };
+                    // Convert raw request to rich request using shared helper
+                    const oauthRequest = buildRequestFromRaw(envelope.request);
+                    // Build request-scoped config using shared helper
+                    const oauthCallbackRequestConfig = buildRequestScopedConfig(envelope.env);
                     const oauthCallbackContext = {
-                        query: oauthCallbackBody.query,
+                        request: oauthRequest,
                     };
                     try {
                         const oauthCallbackHook = config.hooks.oauth_callback;

package/dist/types.d.ts

@@ -274,7 +274,8 @@ export type HasOAuthCallback<Hooks extends ServerHooks> = Hooks extends {
 export type InstallHandlerResult<Hooks extends ServerHooks = ServerHooks> = HasOAuthCallback<Hooks> extends true ? InstallHandlerResponseOAuth : InstallHandlerResponseStandard;
 export type InstallHandler<Hooks extends ServerHooks = ServerHooks> = (ctx: InstallHandlerContext) => Promise<InstallHandlerResult<Hooks>>;
 export interface OAuthCallbackContext {
-    query: Record<string, string>;
+    /** Full HTTP request from the OAuth provider */
+    request: WebhookRequest;
 }
 export interface OAuthCallbackResult {
     env?: Record<string, string>;
@@ -322,6 +323,19 @@ export interface ServerlessServerInstance {
     getHealthStatus(): HealthStatus;
 }
 export type SkedyulServerInstance = DedicatedServerInstance | ServerlessServerInstance;
+/**
+ * Raw HTTP request shape sent over the wire in handler envelopes.
+ * This is the wire format used by both webhooks and OAuth callbacks.
+ * It gets converted to the rich WebhookRequest type at parse time.
+ */
+export interface HandlerRawRequest {
+    method: string;
+    url: string;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body: string;
+}
 /** Raw HTTP request received by webhooks */
 export interface WebhookRequest {
     method: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "0.2.151",
+  "version": "0.2.153",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",