@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/adapters/bluebubbles/index.js

@@ -0,0 +1,119 @@
+import { parseJsonRecord, readBearerOrHeaderToken, readTextBodyWithinLimit } from '@pellux/goodvibes-sdk/platform/adapters/helpers';
+function readRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function conversationKindForChatGuid(chatGuid, isGroup) {
+    if (isGroup)
+        return 'group';
+    if (chatGuid?.includes(';+;'))
+        return 'group';
+    return 'direct';
+}
+export async function handleBlueBubblesSurfaceWebhook(req, context) {
+    const configuredPassword = String(context.configManager.get('surfaces.bluebubbles.password') ?? '')
+        || await context.serviceRegistry.resolveSecret('bluebubbles', 'password')
+        || process.env.BLUEBUBBLES_PASSWORD
+        || '';
+    const url = new URL(req.url);
+    const providedPassword = url.searchParams.get('password')
+        ?? readBearerOrHeaderToken(req, 'x-goodvibes-bluebubbles-token')
+        ?? '';
+    if (configuredPassword && providedPassword !== configuredPassword) {
+        return Response.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+    const rawBody = await readTextBodyWithinLimit(req);
+    if (rawBody instanceof Response)
+        return rawBody;
+    const body = parseJsonRecord(rawBody);
+    if (body instanceof Response)
+        return body;
+    const payload = readRecord(body);
+    if (!payload)
+        return Response.json({ error: 'Invalid JSON body' }, { status: 400 });
+    const message = readRecord(payload.message) ?? payload;
+    const text = readString(message.text) ?? readString(message.message) ?? '';
+    const chatGuid = readString(message.chatGuid) ?? readString(message.chat_guid) ?? readString(payload.chatGuid);
+    const senderId = readString(message.senderId)
+        ?? readString(message.sender)
+        ?? readString(message.handle)
+        ?? readString(payload.senderId);
+    const messageId = readString(message.guid) ?? readString(message.messageId) ?? readString(payload.guid);
+    const isFromMe = Boolean(message.isFromMe ?? message.fromMe ?? payload.isFromMe ?? payload.fromMe);
+    if (isFromMe) {
+        return Response.json({ ok: true, ignored: true, reason: 'from-me' });
+    }
+    const conversationId = chatGuid ?? senderId;
+    if (!conversationId)
+        return Response.json({ error: 'Missing BlueBubbles chat identifier' }, { status: 400 });
+    const policy = await context.authorizeSurfaceIngress({
+        surface: 'bluebubbles',
+        userId: senderId,
+        channelId: conversationId,
+        groupId: conversationId,
+        conversationKind: conversationKindForChatGuid(chatGuid, Boolean(message.isGroup ?? payload.isGroup)),
+        text,
+        mentioned: true,
+        metadata: payload,
+    });
+    if (!policy.allowed) {
+        return Response.json({ error: `Blocked by channel policy: ${policy.reason}` }, { status: 403 });
+    }
+    const binding = await context.routeBindings.upsertBinding({
+        kind: 'channel',
+        surfaceKind: 'bluebubbles',
+        surfaceId: readString(payload.account)
+            ?? readString(context.configManager.get('surfaces.bluebubbles.account'))
+            ?? 'bluebubbles',
+        externalId: conversationId,
+        channelId: conversationId,
+        title: senderId ?? conversationId,
+        metadata: {
+            ...payload,
+            ...(messageId ? { messageId } : {}),
+            ...(chatGuid ? { chatGuid } : {}),
+            ...(senderId ? { senderId } : {}),
+        },
+    });
+    if (!text) {
+        return Response.json({ ok: true, acknowledged: true, bindingId: binding.id });
+    }
+    const controlCommand = context.parseSurfaceControlCommand(text);
+    if (controlCommand) {
+        const message = await context.performSurfaceControlCommand(controlCommand);
+        return Response.json({ ok: true, acknowledged: true, message });
+    }
+    const submission = await context.sessionBroker.submitMessage({
+        routeId: binding.id,
+        surfaceKind: 'bluebubbles',
+        surfaceId: binding.surfaceId,
+        externalId: binding.externalId,
+        threadId: binding.channelId,
+        userId: senderId ?? conversationId,
+        displayName: senderId ?? conversationId,
+        title: binding.title ?? 'BlueBubbles',
+        body: text,
+        metadata: binding.metadata,
+    });
+    if (submission.mode === 'continued-live') {
+        return Response.json({ ok: true, continued: true, sessionId: submission.session.id, agentId: submission.activeAgentId ?? null });
+    }
+    const spawnResult = context.trySpawnAgent({ mode: 'spawn', task: submission.task }, 'handleBlueBubblesSurfaceWebhook', submission.session.id);
+    if (spawnResult instanceof Response)
+        return spawnResult;
+    await context.sessionBroker.bindAgent(submission.session.id, spawnResult.id);
+    context.queueSurfaceReplyFromBinding(submission.routeBinding ?? binding, {
+        agentId: spawnResult.id,
+        task: text,
+        sessionId: submission.session.id,
+    });
+    return Response.json({
+        ok: true,
+        queued: true,
+        bindingId: binding.id,
+        sessionId: submission.session.id,
+        agentId: spawnResult.id,
+    });
+}

package/dist/_internal/platform/adapters/discord/index.d.ts

@@ -0,0 +1,9 @@
+import { DiscordIntegration } from '../../integrations/index.js';
+import type { SurfaceAdapterContext } from '../types.js';
+export declare function handleDiscordSurfaceWebhook(req: Request, context: SurfaceAdapterContext): Promise<Response>;
+export declare function handleDiscordInteractionPayload(bodyRecord: Record<string, unknown>, context: SurfaceAdapterContext, discord?: DiscordIntegration, req?: Request): Promise<Response>;
+export declare function handleDiscordGatewayDispatchPayload(dispatch: {
+    readonly t?: string;
+    readonly d?: Record<string, unknown> | null;
+}, context: SurfaceAdapterContext, discord?: DiscordIntegration): Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/adapters/discord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/adapters/discord/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAA0D,MAAM,6BAA6B,CAAC;AACzH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAqCjH;AAED,wBAAsB,+BAA+B,CACnD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,EAAE,qBAAqB,EAC9B,OAAO,qBAA2B,EAClC,GAAG,GAAE,OAAmF,GACvF,OAAO,CAAC,QAAQ,CAAC,CAwJnB;AAED,wBAAsB,mCAAmC,CACvD,QAAQ,EAAE;IAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAAE,EAC9E,OAAO,EAAE,qBAAqB,EAC9B,OAAO,qBAA2B,GACjC,OAAO,CAAC,QAAQ,CAAC,CAyFnB"}

package/dist/_internal/platform/adapters/discord/index.js

@@ -0,0 +1,255 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { DiscordIntegration, DiscordInteractionResponseType, DiscordInteractionType } from '../../integrations/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export async function handleDiscordSurfaceWebhook(req, context) {
+    const contentLength = parseInt(req.headers.get('content-length') ?? '0', 10);
+    if (contentLength > 1_000_000) {
+        return Response.json({ error: 'Payload too large' }, { status: 413 });
+    }
+    const publicKey = await context.serviceRegistry.resolveSecret('discord', 'publicKey')
+        ?? process.env.DISCORD_PUBLIC_KEY;
+    if (!publicKey) {
+        logger.warn('handleDiscordSurfaceWebhook: DISCORD_PUBLIC_KEY not set — rejecting');
+        return Response.json({ error: 'Webhook not configured' }, { status: 503 });
+    }
+    const signature = req.headers.get('x-signature-ed25519') ?? '';
+    const timestamp = req.headers.get('x-signature-timestamp') ?? '';
+    const rawBody = await req.text();
+    const discord = new DiscordIntegration(await context.serviceRegistry.resolveSecret('discord', 'webhookUrl') ?? process.env.DISCORD_WEBHOOK_URL, await context.serviceRegistry.resolveSecret('discord', 'primary') ?? process.env.DISCORD_BOT_TOKEN);
+    const valid = await discord.verifySignature(rawBody, signature, timestamp, publicKey);
+    if (!valid) {
+        logger.warn('handleDiscordSurfaceWebhook: invalid Ed25519 signature');
+        return new Response('Invalid request signature', { status: 401 });
+    }
+    let bodyRecord;
+    try {
+        bodyRecord = JSON.parse(rawBody);
+    }
+    catch {
+        return new Response('Invalid JSON body', { status: 400 });
+    }
+    return handleDiscordInteractionPayload(bodyRecord, context, discord, req);
+}
+export async function handleDiscordInteractionPayload(bodyRecord, context, discord = new DiscordIntegration(), req = new Request('http://goodvibes.local/webhook/discord', { method: 'POST' })) {
+    const interaction = discord.parseInteraction(bodyRecord);
+    if (interaction.type === DiscordInteractionType.Ping) {
+        return Response.json({ type: DiscordInteractionResponseType.Pong });
+    }
+    if (interaction.type === DiscordInteractionType.ApplicationCommand) {
+        const promptOption = interaction.commandOptions?.find((option) => option.name === 'prompt');
+        const task = typeof promptOption?.value === 'string' ? promptOption.value.trim() : '';
+        const policy = await context.authorizeSurfaceIngress({
+            surface: 'discord',
+            userId: interaction.userId,
+            channelId: interaction.channelId,
+            groupId: interaction.channelId,
+            conversationKind: interaction.channelId ? 'channel' : 'service',
+            text: task,
+            mentioned: true,
+            metadata: {
+                commandName: interaction.commandName,
+            },
+        });
+        if (!policy.allowed) {
+            return Response.json({
+                type: DiscordInteractionResponseType.ChannelMessageWithSource,
+                data: { content: `Blocked by channel policy: ${policy.reason}` },
+            }, { status: 403 });
+        }
+        const binding = await context.routeBindings.upsertBinding({
+            kind: 'channel',
+            surfaceKind: 'discord',
+            surfaceId: interaction.guildId ?? interaction.applicationId ?? 'discord',
+            externalId: interaction.channelId ?? interaction.id,
+            channelId: interaction.channelId,
+            title: interaction.commandName ?? 'discord',
+            metadata: {
+                userId: interaction.userId,
+                commandName: interaction.commandName,
+                applicationId: interaction.applicationId,
+                interactionToken: interaction.token,
+            },
+        });
+        const deferredResponse = Response.json({
+            type: DiscordInteractionResponseType.DeferredChannelMessageWithSource,
+        });
+        if (!task) {
+            return deferredResponse;
+        }
+        const controlCommand = context.parseSurfaceControlCommand(task);
+        if (controlCommand) {
+            const message = await context.performSurfaceControlCommand(controlCommand);
+            return Response.json({
+                type: DiscordInteractionResponseType.ChannelMessageWithSource,
+                data: { content: message },
+            });
+        }
+        const appId = interaction.applicationId;
+        const token = interaction.token;
+        setImmediate(() => {
+            void (async () => {
+                const submission = await context.sessionBroker.submitMessage({
+                    routeId: binding.id,
+                    surfaceKind: 'discord',
+                    surfaceId: binding.surfaceId,
+                    externalId: interaction.channelId ?? interaction.id,
+                    threadId: interaction.channelId,
+                    userId: interaction.userId,
+                    displayName: interaction.userId,
+                    title: interaction.commandName ?? 'discord',
+                    body: task,
+                    metadata: {
+                        applicationId: appId,
+                        interactionToken: token,
+                    },
+                });
+                if (submission.mode === 'continued-live') {
+                    await discord
+                        .editOriginalResponse(appId, token, `Continuing session ${submission.session.id} via agent ${submission.activeAgentId}.`)
+                        .catch(() => { });
+                    return;
+                }
+                const spawnResult = context.trySpawnAgent({ mode: 'spawn', task: submission.task }, 'handleDiscordSurfaceWebhook', submission.session.id);
+                if (spawnResult instanceof Response) {
+                    const payload = await spawnResult.json();
+                    const message = payload.error ?? 'Agent spawn failed';
+                    logger.error('handleDiscordSurfaceWebhook: spawn failed', { error: message });
+                    await discord.editOriginalResponse(appId, token, `Agent spawn failed: ${message}`).catch(() => { });
+                    return;
+                }
+                await context.sessionBroker.bindAgent(submission.session.id, spawnResult.id);
+                context.queueSurfaceReplyFromBinding(submission.routeBinding ?? binding, {
+                    agentId: spawnResult.id,
+                    task,
+                    sessionId: submission.session.id,
+                });
+                const embed = discord.formatAgentResult(spawnResult.id, task, `Session ${submission.session.id} active. Result will be posted here when complete.`);
+                await discord
+                    .editOriginalResponse(appId, token, '', [embed])
+                    .catch((error) => {
+                    logger.warn('handleDiscordSurfaceWebhook: follow-up failed', {
+                        error: summarizeError(error),
+                    });
+                });
+            })();
+        });
+        return deferredResponse;
+    }
+    if (interaction.type === DiscordInteractionType.MessageComponent) {
+        const data = (interaction.raw.data ?? {});
+        const customId = typeof data.custom_id === 'string' ? data.custom_id : '';
+        if (customId) {
+            const policy = await context.authorizeSurfaceIngress({
+                surface: 'discord',
+                userId: interaction.userId,
+                channelId: interaction.channelId,
+                groupId: interaction.channelId,
+                conversationKind: interaction.channelId ? 'channel' : 'service',
+                text: customId,
+                mentioned: true,
+                metadata: { interactive: true },
+            });
+            if (!policy.allowed) {
+                return Response.json({
+                    type: DiscordInteractionResponseType.ChannelMessageWithSource,
+                    data: { content: `Blocked by channel policy: ${policy.reason}` },
+                }, { status: 403 });
+            }
+            const message = await context.performInteractiveSurfaceAction(customId, 'discord', req);
+            return Response.json({
+                type: DiscordInteractionResponseType.ChannelMessageWithSource,
+                data: { content: message },
+            });
+        }
+    }
+    return Response.json({ type: DiscordInteractionResponseType.DeferredUpdateMessage });
+}
+export async function handleDiscordGatewayDispatchPayload(dispatch, context, discord = new DiscordIntegration()) {
+    if (!dispatch.d)
+        return new Response(null, { status: 204 });
+    if (dispatch.t === 'INTERACTION_CREATE') {
+        return handleDiscordInteractionPayload(dispatch.d, context, discord);
+    }
+    if (dispatch.t !== 'MESSAGE_CREATE') {
+        return new Response(null, { status: 204 });
+    }
+    const author = (dispatch.d.author ?? {});
+    if (author.bot === true)
+        return new Response(null, { status: 204 });
+    const content = typeof dispatch.d.content === 'string' ? dispatch.d.content.trim() : '';
+    if (!content)
+        return new Response(null, { status: 204 });
+    const channelId = typeof dispatch.d.channel_id === 'string' ? dispatch.d.channel_id : undefined;
+    const guildId = typeof dispatch.d.guild_id === 'string' ? dispatch.d.guild_id : undefined;
+    const messageId = typeof dispatch.d.id === 'string' ? dispatch.d.id : undefined;
+    const userId = typeof author.id === 'string' ? author.id : undefined;
+    const mentioned = Array.isArray(dispatch.d.mentions) && dispatch.d.mentions.length > 0;
+    const policy = await context.authorizeSurfaceIngress({
+        surface: 'discord',
+        userId,
+        channelId,
+        groupId: channelId,
+        workspaceId: guildId,
+        conversationKind: channelId ? 'channel' : 'service',
+        text: content,
+        mentioned,
+        metadata: {
+            gatewayEvent: dispatch.t,
+            messageId,
+        },
+    });
+    if (!policy.allowed) {
+        return Response.json({ ok: false, error: `Blocked by channel policy: ${policy.reason}` }, { status: 403 });
+    }
+    const binding = await context.routeBindings.upsertBinding({
+        kind: 'channel',
+        surfaceKind: 'discord',
+        surfaceId: guildId ?? 'discord',
+        externalId: channelId ?? messageId ?? 'discord',
+        channelId,
+        title: 'Discord message',
+        metadata: {
+            userId,
+            messageId,
+            gatewayEvent: dispatch.t,
+        },
+    });
+    const submission = await context.sessionBroker.submitMessage({
+        routeId: binding.id,
+        surfaceKind: 'discord',
+        surfaceId: binding.surfaceId,
+        externalId: binding.externalId,
+        threadId: binding.channelId,
+        userId,
+        displayName: typeof author.username === 'string' ? author.username : userId,
+        title: 'Discord message',
+        body: content,
+        metadata: {
+            messageId,
+            gatewayEvent: dispatch.t,
+        },
+    });
+    if (submission.mode === 'continued-live') {
+        return Response.json({
+            ok: true,
+            continued: true,
+            sessionId: submission.session.id,
+            agentId: submission.activeAgentId,
+        });
+    }
+    const spawnResult = context.trySpawnAgent({ mode: 'spawn', task: submission.task }, 'handleDiscordGatewayDispatchPayload', submission.session.id);
+    if (spawnResult instanceof Response)
+        return spawnResult;
+    await context.sessionBroker.bindAgent(submission.session.id, spawnResult.id);
+    context.queueSurfaceReplyFromBinding(submission.routeBinding ?? binding, {
+        agentId: spawnResult.id,
+        task: content,
+        sessionId: submission.session.id,
+    });
+    return Response.json({
+        ok: true,
+        queued: true,
+        sessionId: submission.session.id,
+        agentId: spawnResult.id,
+    });
+}

package/dist/_internal/platform/adapters/github/index.d.ts

@@ -0,0 +1,8 @@
+import type { ServiceRegistry } from '../../config/service-registry.js';
+import type { TrySpawnAgentFn } from '../types.js';
+export declare function handleGitHubAutomationWebhook(req: Request, context: {
+    readonly serviceRegistry: ServiceRegistry;
+    readonly githubWebhookSecret: string | null;
+    readonly trySpawnAgent: TrySpawnAgentFn;
+}): Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/adapters/github/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/adapters/github/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAUnD,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE;IACP,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC;CACzC,GACA,OAAO,CAAC,QAAQ,CAAC,CAoDnB"}

package/dist/_internal/platform/adapters/github/index.js

@@ -0,0 +1,58 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { GitHubIntegration } from '@pellux/goodvibes-sdk/platform/integrations/github';
+function parseJsonRecord(rawBody) {
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch {
+        return Response.json({ error: 'Invalid JSON body' }, { status: 400 });
+    }
+}
+export async function handleGitHubAutomationWebhook(req, context) {
+    const contentLength = parseInt(req.headers.get('content-length') ?? '0', 10);
+    if (contentLength > 1_000_000) {
+        return Response.json({ error: 'Payload too large' }, { status: 413 });
+    }
+    const rawBody = await req.text();
+    const githubWebhookSecret = context.githubWebhookSecret
+        ?? await context.serviceRegistry.resolveSecret('github', 'signingSecret');
+    if (!githubWebhookSecret) {
+        logger.warn('handleGitHubAutomationWebhook: GITHUB_WEBHOOK_SECRET not configured — rejecting');
+        return Response.json({ error: 'Webhook not configured' }, { status: 503 });
+    }
+    const signature = req.headers.get('x-hub-signature-256') ?? '';
+    if (!signature) {
+        return Response.json({ error: 'Missing X-Hub-Signature-256 header' }, { status: 401 });
+    }
+    if (!GitHubIntegration.verifySignature(rawBody, signature, githubWebhookSecret)) {
+        logger.warn('handleGitHubAutomationWebhook: GitHub webhook signature verification failed');
+        return Response.json({ error: 'Invalid webhook signature' }, { status: 401 });
+    }
+    const body = parseJsonRecord(rawBody);
+    if (body instanceof Response)
+        return body;
+    const event = GitHubIntegration.parseEvent(req.headers, body);
+    const prompt = GitHubIntegration.eventToPrompt(event);
+    if (prompt === null) {
+        logger.info('handleGitHubAutomationWebhook: event ignored (no prompt generated)', {
+            type: event.type,
+            action: event.action,
+        });
+        return Response.json({ acknowledged: true, queued: false, reason: 'Event not actionable' });
+    }
+    const spawnResult = context.trySpawnAgent({ mode: 'spawn', task: prompt }, 'handleGitHubAutomationWebhook');
+    if (spawnResult instanceof Response)
+        return spawnResult;
+    logger.info('handleGitHubAutomationWebhook: spawned agent', {
+        type: event.type,
+        action: event.action,
+        agentId: spawnResult.id,
+    });
+    return Response.json({
+        acknowledged: true,
+        queued: true,
+        agentId: spawnResult.id,
+        eventType: event.type,
+        action: event.action,
+    });
+}

package/dist/_internal/platform/adapters/google-chat/index.d.ts

@@ -0,0 +1,3 @@
+import type { SurfaceAdapterContext } from '../types.js';
+export declare function handleGoogleChatSurfaceWebhook(req: Request, context: SurfaceAdapterContext): Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/adapters/google-chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/adapters/google-chat/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAUzD,wBAAsB,8BAA8B,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,QAAQ,CAAC,CA4GpH"}

package/dist/_internal/platform/adapters/google-chat/index.js

@@ -0,0 +1,105 @@
+function readRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+export async function handleGoogleChatSurfaceWebhook(req, context) {
+    const contentLength = parseInt(req.headers.get('content-length') ?? '0', 10);
+    if (contentLength > 1_000_000) {
+        return Response.json({ error: 'Payload too large' }, { status: 413 });
+    }
+    const verificationToken = String(context.configManager.get('surfaces.googleChat.verificationToken') ?? '')
+        || await context.serviceRegistry.resolveSecret('google-chat', 'signingSecret')
+        || process.env.GOOGLE_CHAT_VERIFICATION_TOKEN
+        || '';
+    const body = await req.json().catch(() => null);
+    const payload = readRecord(body);
+    if (!payload)
+        return Response.json({ error: 'Invalid JSON body' }, { status: 400 });
+    const providedToken = readString(payload.token) ?? req.headers.get('x-goog-chat-token') ?? '';
+    if (verificationToken && providedToken !== verificationToken) {
+        return Response.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+    const eventType = readString(payload.type) ?? 'MESSAGE';
+    if (eventType !== 'MESSAGE' && eventType !== 'ADDED_TO_SPACE') {
+        return Response.json({ text: 'ignored' });
+    }
+    const message = readRecord(payload.message);
+    const space = readRecord(payload.space);
+    const user = readRecord(payload.user) ?? readRecord(message?.sender);
+    const thread = readRecord(message?.thread);
+    const text = readString(message?.argumentText) ?? readString(message?.text) ?? '';
+    const spaceName = readString(space?.name);
+    if (!spaceName)
+        return Response.json({ text: 'missing space' }, { status: 400 });
+    const threadName = readString(thread?.name);
+    const policy = await context.authorizeSurfaceIngress({
+        surface: 'google-chat',
+        userId: readString(user?.name),
+        channelId: spaceName,
+        groupId: spaceName,
+        threadId: threadName,
+        workspaceId: readString(payload.hostApp),
+        conversationKind: threadName ? 'thread' : 'channel',
+        text,
+        mentioned: true,
+        metadata: {
+            eventType,
+            spaceDisplayName: readString(space?.displayName),
+            userDisplayName: readString(user?.displayName),
+        },
+    });
+    if (!policy.allowed) {
+        return Response.json({ text: `Blocked by channel policy: ${policy.reason}` }, { status: 403 });
+    }
+    const binding = await context.routeBindings.upsertBinding({
+        kind: threadName ? 'thread' : 'channel',
+        surfaceKind: 'google-chat',
+        surfaceId: readString(context.configManager.get('surfaces.googleChat.appId')) ?? 'google-chat',
+        externalId: threadName ?? spaceName,
+        channelId: spaceName,
+        threadId: threadName,
+        title: readString(space?.displayName) ?? spaceName,
+        metadata: {
+            eventType,
+            userName: readString(user?.name),
+        },
+    });
+    if (!text) {
+        return Response.json({ text: 'Acknowledged.' });
+    }
+    const controlCommand = context.parseSurfaceControlCommand(text);
+    if (controlCommand) {
+        const message = await context.performSurfaceControlCommand(controlCommand);
+        return Response.json({ text: message });
+    }
+    const submission = await context.sessionBroker.submitMessage({
+        routeId: binding.id,
+        surfaceKind: 'google-chat',
+        surfaceId: binding.surfaceId,
+        externalId: binding.externalId,
+        threadId: binding.threadId ?? binding.channelId,
+        userId: readString(user?.name),
+        displayName: readString(user?.displayName),
+        title: binding.title ?? 'Google Chat',
+        body: text,
+        metadata: {
+            eventType,
+            spaceName,
+        },
+    });
+    if (submission.mode === 'continued-live') {
+        return Response.json({ text: `Continuing session ${submission.session.id}.` });
+    }
+    const spawnResult = context.trySpawnAgent({ mode: 'spawn', task: submission.task }, 'handleGoogleChatSurfaceWebhook', submission.session.id);
+    if (spawnResult instanceof Response)
+        return spawnResult;
+    await context.sessionBroker.bindAgent(submission.session.id, spawnResult.id);
+    context.queueSurfaceReplyFromBinding(submission.routeBinding ?? binding, {
+        agentId: spawnResult.id,
+        task: text,
+        sessionId: submission.session.id,
+    });
+    return Response.json({ text: `Running ${spawnResult.id}` });
+}

package/dist/_internal/platform/adapters/imessage/index.d.ts

@@ -0,0 +1,3 @@
+import type { SurfaceAdapterContext } from '../types.js';
+export declare function handleIMessageSurfaceWebhook(req: Request, context: SurfaceAdapterContext): Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/adapters/imessage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/adapters/imessage/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAUzD,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAgFlH"}

package/dist/_internal/platform/adapters/imessage/index.js

@@ -0,0 +1,84 @@
+import { parseJsonRecord, readBearerOrHeaderToken, readTextBodyWithinLimit } from '@pellux/goodvibes-sdk/platform/adapters/helpers';
+function readRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+export async function handleIMessageSurfaceWebhook(req, context) {
+    const configuredToken = String(context.configManager.get('surfaces.imessage.token') ?? '')
+        || await context.serviceRegistry.resolveSecret('imessage', 'primary')
+        || process.env.IMESSAGE_BRIDGE_TOKEN
+        || '';
+    if (configuredToken) {
+        const providedToken = readBearerOrHeaderToken(req, 'x-goodvibes-imessage-token');
+        if (providedToken !== configuredToken) {
+            return Response.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+    }
+    const rawBody = await readTextBodyWithinLimit(req);
+    if (rawBody instanceof Response)
+        return rawBody;
+    const body = parseJsonRecord(rawBody);
+    if (body instanceof Response)
+        return body;
+    const payload = readRecord(body);
+    if (!payload)
+        return Response.json({ error: 'Invalid JSON body' }, { status: 400 });
+    const chatId = readString(payload.chatId) ?? readString(payload.conversationId) ?? readString(payload.source);
+    const message = readString(payload.message) ?? readString(payload.text) ?? '';
+    if (!chatId)
+        return Response.json({ error: 'Missing chatId' }, { status: 400 });
+    const policy = await context.authorizeSurfaceIngress({
+        surface: 'imessage',
+        userId: chatId,
+        channelId: chatId,
+        groupId: chatId,
+        threadId: readString(payload.threadId),
+        conversationKind: readString(payload.threadId) ? 'thread' : 'direct',
+        text: message,
+        mentioned: true,
+        metadata: payload,
+    });
+    if (!policy.allowed) {
+        return Response.json({ error: `Blocked by channel policy: ${policy.reason}` }, { status: 403 });
+    }
+    const binding = await context.routeBindings.upsertBinding({
+        kind: readString(payload.threadId) ? 'thread' : 'channel',
+        surfaceKind: 'imessage',
+        surfaceId: readString(payload.account) ?? readString(context.configManager.get('surfaces.imessage.account')) ?? 'imessage',
+        externalId: readString(payload.threadId) ?? chatId,
+        channelId: chatId,
+        threadId: readString(payload.threadId),
+        title: chatId,
+        metadata: { ...payload },
+    });
+    if (!message) {
+        return Response.json({ acknowledged: true, queued: false, bindingId: binding.id });
+    }
+    const submission = await context.sessionBroker.submitMessage({
+        routeId: binding.id,
+        surfaceKind: 'imessage',
+        surfaceId: binding.surfaceId,
+        externalId: binding.externalId,
+        threadId: binding.threadId ?? binding.channelId,
+        userId: chatId,
+        displayName: chatId,
+        title: chatId,
+        body: message,
+        metadata: payload,
+    });
+    if (submission.mode === 'continued-live') {
+        return Response.json({ acknowledged: true, continued: true, sessionId: submission.session.id, agentId: submission.activeAgentId ?? null });
+    }
+    const spawnResult = context.trySpawnAgent({ mode: 'spawn', task: submission.task }, 'handleIMessageSurfaceWebhook', submission.session.id);
+    if (spawnResult instanceof Response)
+        return spawnResult;
+    await context.sessionBroker.bindAgent(submission.session.id, spawnResult.id);
+    context.queueSurfaceReplyFromBinding(submission.routeBinding ?? binding, {
+        agentId: spawnResult.id,
+        task: message,
+        sessionId: submission.session.id,
+    });
+    return Response.json({ acknowledged: true, queued: true, bindingId: binding.id, sessionId: submission.session.id, agentId: spawnResult.id });
+}