skedyul 0.1.20 → 0.1.22

package/dist/core/client.d.ts

@@ -33,6 +33,20 @@ export declare const workplace: {
     list(args?: ListArgs): Promise<Workplace[]>;
     get(id: string): Promise<Workplace>;
 };
+export interface ReceiveMessageInput {
+    /** Communication channel ID */
+    communicationChannelId: string;
+    /** Sender's identifier (e.g., phone number, email) */
+    from: string;
+    /** Message content */
+    message: string;
+    /** Optional remote/external message ID (e.g., Twilio MessageSid) */
+    remoteId?: string;
+}
+export interface ReceiveMessageResponse {
+    success: boolean;
+    messageId?: string;
+}
 export declare const communicationChannel: {
     /**
      * List communication channels with optional filters.
@@ -48,5 +62,23 @@ export declare const communicationChannel: {
      */
     list(args?: ListArgs): Promise<CommunicationChannel[]>;
     get(id: string): Promise<CommunicationChannel | null>;
+    /**
+     * Receive an inbound message on a communication channel.
+     *
+     * This is typically called from webhook handlers to process incoming messages
+     * (e.g., SMS from Twilio, emails, WhatsApp messages).
+     *
+     * @example
+     * ```ts
+     * // In a webhook handler
+     * const result = await communicationChannel.receiveMessage({
+     *   communicationChannelId: channel.id,
+     *   from: '+1234567890',
+     *   message: 'Hello!',
+     *   remoteId: 'twilio-message-sid-123',
+     * });
+     * ```
+     */
+    receiveMessage(input: ReceiveMessageInput): Promise<ReceiveMessageResponse>;
 };
 export {};

package/dist/core/client.js

@@ -97,4 +97,30 @@ exports.communicationChannel = {
         const payload = (await callCore('communicationChannel.get', { id }));
         return payload.channel;
     },
+    /**
+     * Receive an inbound message on a communication channel.
+     *
+     * This is typically called from webhook handlers to process incoming messages
+     * (e.g., SMS from Twilio, emails, WhatsApp messages).
+     *
+     * @example
+     * ```ts
+     * // In a webhook handler
+     * const result = await communicationChannel.receiveMessage({
+     *   communicationChannelId: channel.id,
+     *   from: '+1234567890',
+     *   message: 'Hello!',
+     *   remoteId: 'twilio-message-sid-123',
+     * });
+     * ```
+     */
+    async receiveMessage(input) {
+        const payload = (await callCore('communicationChannel.receiveMessage', {
+            communicationChannelId: input.communicationChannelId,
+            from: input.from,
+            message: input.message,
+            ...(input.remoteId ? { remoteId: input.remoteId } : {}),
+        }));
+        return payload;
+    },
 };

package/dist/core/types.d.ts

@@ -20,9 +20,12 @@ export interface Message {
 }
 export interface WebhookRequest {
     method: string;
+    url?: string;
+    path?: string;
     headers: Record<string, string>;
-    body?: unknown;
     query?: Record<string, string | undefined>;
+    body?: unknown;
+    rawBody?: Buffer;
 }
 export interface WebhookResponse {
     status: number;

package/dist/server.js

@@ -354,23 +354,27 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         }
     };
 }
-function parseJSONBody(req) {
+function readRawRequestBody(req) {
     return new Promise((resolve, reject) => {
         let body = '';
         req.on('data', (chunk) => {
             body += chunk.toString();
         });
         req.on('end', () => {
-            try {
-                resolve(body ? JSON.parse(body) : {});
-            }
-            catch (err) {
-                reject(err);
-            }
+            resolve(body);
         });
         req.on('error', reject);
     });
 }
+async function parseJSONBody(req) {
+    const rawBody = await readRawRequestBody(req);
+    try {
+        return rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch (err) {
+        throw err;
+    }
+}
 function sendJSON(res, statusCode, data) {
     res.writeHead(statusCode, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
@@ -551,22 +555,36 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                 return;
             }
             if (pathname === '/core/webhook' && req.method === 'POST') {
-                let webhookBody = undefined;
+                let rawWebhookBody;
+                try {
+                    rawWebhookBody = await readRawRequestBody(req);
+                }
+                catch {
+                    sendJSON(res, 400, { status: 'parse-error' });
+                    return;
+                }
+                let webhookBody;
                 try {
-                    webhookBody = (await parseJSONBody(req));
+                    webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
                 }
                 catch {
                     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 webhookRequest = {
                     method: req.method,
-                    headers: Object.fromEntries(Object.entries(req.headers).map(([key, value]) => [
-                        key,
-                        typeof value === 'string' ? value : value?.[0] ?? '',
-                    ])),
+                    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(webhookRequest);
                 res.writeHead(webhookResponse.status, {
@@ -675,18 +693,29 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                     return createResponse(result.status, result.payload, headers);
                 }
                 if (path === '/core/webhook' && method === 'POST') {
-                    let webhookBody = undefined;
+                    const rawWebhookBody = event.body ?? '';
+                    let webhookBody;
                     try {
-                        webhookBody = event.body ? JSON.parse(event.body) : {};
+                        webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
                     }
                     catch {
                         return createResponse(400, { status: 'parse-error' }, headers);
                     }
+                    const forwardedProto = event.headers?.['x-forwarded-proto'] ??
+                        event.headers?.['X-Forwarded-Proto'];
+                    const protocol = forwardedProto ?? 'https';
+                    const host = event.headers?.host ?? event.headers?.Host ?? 'localhost';
+                    const webhookUrl = `${protocol}://${host}${event.path}`;
                     const webhookRequest = {
                         method,
                         headers: event.headers ?? {},
                         body: webhookBody,
                         query: event.queryStringParameters ?? {},
+                        url: webhookUrl,
+                        path: event.path,
+                        rawBody: rawWebhookBody
+                            ? Buffer.from(rawWebhookBody, 'utf-8')
+                            : undefined,
                     };
                     const webhookResponse = await service_1.coreApiService.dispatchWebhook(webhookRequest);
                     return createResponse(webhookResponse.status, webhookResponse.body ?? {}, headers);

package/dist/types.d.ts

@@ -127,7 +127,11 @@ export interface WebhookResponse {
     headers?: Record<string, string>;
     body?: unknown;
 }
-export type WebhookHandler = (request: WebhookRequest) => Promise<WebhookResponse> | WebhookResponse;
+export interface WebhookContext {
+    /** Environment variables available during webhook handling */
+    env: Record<string, string | undefined>;
+}
+export type WebhookHandler = (request: WebhookRequest, context: WebhookContext) => Promise<WebhookResponse> | WebhookResponse;
 export interface WebhookDefinition {
     name: string;
     description: string;

package/package.json

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