@wingman-ai/gateway 0.1.0

package/dist/gateway/http/webhooks.cjs

@@ -0,0 +1,353 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    handleWebhooksApi: ()=>handleWebhooksApi,
+    createWebhookStore: ()=>createWebhookStore,
+    handleWebhookInvoke: ()=>handleWebhookInvoke
+});
+const agentInvoker_cjs_namespaceObject = require("../../cli/core/agentInvoker.cjs");
+const outputManager_cjs_namespaceObject = require("../../cli/core/outputManager.cjs");
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const WEBHOOK_PRESETS = new Set([
+    "gog-gmail"
+]);
+const normalizePreset = (value)=>{
+    if (!value) return;
+    const trimmed = value.trim();
+    if (!trimmed || "custom" === trimmed) return;
+    return WEBHOOK_PRESETS.has(trimmed) ? trimmed : void 0;
+};
+const formatGogGmailContent = (payload, webhookName, eventLabel)=>{
+    const payloadMessages = Array.isArray(payload?.messages) ? payload.messages : [];
+    const dataMessages = Array.isArray(payload?.data?.messages) ? payload.data.messages : [];
+    const candidate = payload?.message || payload?.email || payload?.data?.message || payloadMessages[0] || dataMessages[0] || null;
+    const header = `Gmail update received${eventLabel ? ` (${eventLabel})` : ""} for "${webhookName}".`;
+    if (!candidate) {
+        const fallback = payload ? JSON.stringify(payload, null, 2) : "{}";
+        return `${header}\n\nPayload:\n${fallback}`;
+    }
+    const subject = candidate.subject || candidate.headers?.subject || candidate.headers?.Subject || "(no subject)";
+    const from = candidate.from || candidate.headers?.from || candidate.headers?.From || "unknown sender";
+    const snippet = candidate.snippet || candidate.preview || "";
+    const body = candidate.body || candidate.text || candidate.html || "";
+    const id = candidate.id || candidate.messageId || "";
+    const lines = [
+        header,
+        `From: ${from}`,
+        `Subject: ${subject}`
+    ];
+    if (id) lines.push(`Message ID: ${id}`);
+    if (snippet) lines.push(`Snippet: ${snippet}`);
+    if (body) lines.push("", body);
+    return lines.join("\n");
+};
+const createWebhookStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)(configDir, {
+            recursive: true
+        });
+        return (0, external_node_path_namespaceObject.join)(configDir, "webhooks.json");
+    };
+    return {
+        load: ()=>{
+            const path = resolvePath();
+            if (!(0, external_node_fs_namespaceObject.existsSync)(path)) return [];
+            try {
+                const raw = (0, external_node_fs_namespaceObject.readFileSync)(path, "utf-8");
+                const parsed = JSON.parse(raw);
+                return Array.isArray(parsed) ? parsed : [];
+            } catch  {
+                return [];
+            }
+        },
+        save: (webhooks)=>{
+            const path = resolvePath();
+            (0, external_node_fs_namespaceObject.writeFileSync)(path, JSON.stringify(webhooks, null, 2));
+        },
+        generateSecret: ()=>(0, external_node_crypto_namespaceObject.randomUUID)().replace(/-/g, "") + (0, external_node_crypto_namespaceObject.randomUUID)().replace(/-/g, "")
+    };
+};
+const agentExists = (ctx, agentId)=>{
+    const loader = new agentLoader_cjs_namespaceObject.AgentLoader(ctx.configDir, ctx.workspace, ctx.getWingmanConfig());
+    const configs = loader.loadAllAgentConfigs();
+    return Boolean(configs.find((config)=>config.name === agentId));
+};
+const sessionExists = async (ctx, agentId, sessionId)=>{
+    const manager = await ctx.getSessionManager(agentId);
+    return Boolean(manager.getSession(sessionId));
+};
+const handleWebhooksApi = async (ctx, store, req, url)=>{
+    if ("/api/webhooks" === url.pathname) {
+        if ("GET" === req.method) {
+            const webhooks = store.load();
+            return new Response(JSON.stringify(webhooks, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("POST" === req.method) {
+            const body = await req.json();
+            const id = body?.id?.trim();
+            const name = body?.name?.trim();
+            const agentId = body?.agentId?.trim();
+            if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) return new Response("Invalid webhook id", {
+                status: 400
+            });
+            if (!name) return new Response("Webhook name required", {
+                status: 400
+            });
+            if (!agentId) return new Response("agentId required", {
+                status: 400
+            });
+            if (!agentExists(ctx, agentId)) return new Response("Invalid agentId", {
+                status: 400
+            });
+            const sessionId = body?.sessionId?.trim();
+            if (sessionId) {
+                const exists = await sessionExists(ctx, agentId, sessionId);
+                if (!exists) return new Response("Invalid sessionId", {
+                    status: 400
+                });
+            }
+            const webhooks = store.load();
+            if (webhooks.some((hook)=>hook.id === id)) return new Response("Webhook already exists", {
+                status: 409
+            });
+            const presetValue = normalizePreset(body?.preset);
+            if (body?.preset && !presetValue && "custom" !== body.preset.trim()) return new Response("Invalid preset", {
+                status: 400
+            });
+            const webhook = {
+                id,
+                name,
+                agentId,
+                secret: body?.secret?.trim() || store.generateSecret(),
+                enabled: body?.enabled ?? true,
+                eventLabel: body?.eventLabel?.trim() || void 0,
+                preset: presetValue,
+                sessionId: sessionId || void 0,
+                createdAt: Date.now()
+            };
+            webhooks.unshift(webhook);
+            store.save(webhooks);
+            return new Response(JSON.stringify(webhook, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const webhookMatch = url.pathname.match(/^\/api\/webhooks\/([^/]+)$/);
+    if (!webhookMatch) return null;
+    const webhookId = decodeURIComponent(webhookMatch[1]);
+    const webhooks = store.load();
+    const webhook = webhooks.find((hook)=>hook.id === webhookId);
+    if ("GET" === req.method) {
+        if (!webhook) return new Response("Webhook not found", {
+            status: 404
+        });
+        return new Response(JSON.stringify(webhook, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("PUT" === req.method) {
+        if (!webhook) return new Response("Webhook not found", {
+            status: 404
+        });
+        const body = await req.json();
+        const nextAgentId = body?.agentId?.trim() || webhook.agentId;
+        if (!agentExists(ctx, nextAgentId)) return new Response("Invalid agentId", {
+            status: 400
+        });
+        const hasPreset = Object.prototype.hasOwnProperty.call(body ?? {}, "preset");
+        const presetValue = hasPreset ? normalizePreset(body?.preset) : webhook.preset;
+        if (hasPreset && body?.preset && !presetValue && "custom" !== body.preset.trim()) return new Response("Invalid preset", {
+            status: 400
+        });
+        const hasSessionId = Object.prototype.hasOwnProperty.call(body ?? {}, "sessionId");
+        let nextSessionId = webhook.sessionId;
+        if (hasSessionId) {
+            const trimmed = body?.sessionId?.trim();
+            if (trimmed) {
+                const exists = await sessionExists(ctx, nextAgentId, trimmed);
+                if (!exists) return new Response("Invalid sessionId", {
+                    status: 400
+                });
+                nextSessionId = trimmed;
+            } else nextSessionId = void 0;
+        }
+        const updated = {
+            ...webhook,
+            name: body?.name?.trim() || webhook.name,
+            agentId: nextAgentId,
+            secret: body?.secret?.trim() || webhook.secret,
+            enabled: body?.enabled ?? webhook.enabled,
+            eventLabel: body?.eventLabel?.trim() || void 0,
+            preset: presetValue,
+            sessionId: nextSessionId
+        };
+        const nextWebhooks = webhooks.map((hook)=>hook.id === webhookId ? updated : hook);
+        store.save(nextWebhooks);
+        return new Response(JSON.stringify(updated, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        if (!webhook) return new Response("Webhook not found", {
+            status: 404
+        });
+        const nextWebhooks = webhooks.filter((hook)=>hook.id !== webhookId);
+        store.save(nextWebhooks);
+        return new Response(JSON.stringify({
+            ok: true
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+const handleWebhookInvoke = async (ctx, store, req, url)=>{
+    const match = url.pathname.match(/^\/webhooks\/([^/]+)$/);
+    if (!match) return null;
+    if ("POST" !== req.method) return new Response("Method Not Allowed", {
+        status: 405
+    });
+    const webhookId = decodeURIComponent(match[1]);
+    const webhooks = store.load();
+    const webhook = webhooks.find((hook)=>hook.id === webhookId);
+    if (!webhook) return new Response("Webhook not found", {
+        status: 404
+    });
+    if (!webhook.enabled) return new Response("Webhook disabled", {
+        status: 403
+    });
+    const secret = req.headers.get("x-wingman-secret") || url.searchParams.get("secret") || "";
+    if (!secret || secret !== webhook.secret) return new Response("Unauthorized", {
+        status: 401
+    });
+    let body = null;
+    let rawText = null;
+    try {
+        body = await req.json();
+    } catch  {
+        try {
+            rawText = await req.text();
+        } catch  {
+            rawText = null;
+        }
+    }
+    const eventLabel = "string" == typeof body?.event ? body.event : webhook.eventLabel;
+    const directPrompt = "string" == typeof body?.prompt ? body.prompt : "string" == typeof body?.content ? body.content : "string" == typeof body?.message ? body.message : "";
+    const payloadText = rawText || (null != body ? JSON.stringify(body, null, 2) : "");
+    const content = directPrompt || ("gog-gmail" === webhook.preset ? formatGogGmailContent(body ?? {}, webhook.name, eventLabel) : `Webhook "${webhook.name}" triggered${eventLabel ? ` (${eventLabel})` : ""}.\n\nPayload:\n${payloadText || "{}"}`);
+    const agentId = webhook.agentId;
+    const defaultSessionKey = `agent:${agentId}:webhook:${webhook.id}`;
+    let sessionKey = defaultSessionKey;
+    try {
+        const sessionManager = await ctx.getSessionManager(agentId);
+        sessionKey = webhook.sessionId || defaultSessionKey;
+        if (webhook.sessionId) {
+            const target = sessionManager.getSession(webhook.sessionId);
+            if (!target) return new Response("Target session not found", {
+                status: 404
+            });
+        } else sessionManager.getOrCreateSession(sessionKey, agentId, `Webhook: ${webhook.name}`);
+        sessionManager.updateSession(sessionKey, {
+            lastMessagePreview: content.substring(0, 200)
+        });
+        const existing = sessionManager.getSession(sessionKey);
+        if (existing) sessionManager.updateSession(sessionKey, {
+            messageCount: existing.messageCount + 1
+        });
+        sessionManager.updateSessionMetadata(sessionKey, {
+            source: "webhook",
+            webhookId: webhook.id,
+            webhookName: webhook.name,
+            eventLabel: eventLabel || void 0,
+            webhookPreset: webhook.preset
+        });
+        const outputManager = new outputManager_cjs_namespaceObject.OutputManager("interactive");
+        const workspace = ctx.resolveAgentWorkspace(agentId);
+        const session = sessionManager.getSession(sessionKey);
+        const workdir = session?.metadata?.workdir ?? null;
+        const defaultOutputDir = ctx.resolveDefaultOutputDir(agentId);
+        const invoker = new agentInvoker_cjs_namespaceObject.AgentInvoker({
+            workspace,
+            configDir: ctx.configDir,
+            outputManager,
+            logger: ctx.logger,
+            sessionManager,
+            workdir,
+            defaultOutputDir
+        });
+        invoker.invokeAgent(agentId, content, sessionKey);
+    } catch (error) {
+        ctx.logger.error("Webhook agent invocation failed", error);
+        return new Response("Webhook invocation failed", {
+            status: 500
+        });
+    }
+    const updatedWebhooks = webhooks.map((hook)=>hook.id === webhook.id ? {
+            ...hook,
+            lastTriggeredAt: Date.now()
+        } : hook);
+    store.save(updatedWebhooks);
+    return new Response(JSON.stringify({
+        ok: true,
+        sessionId: sessionKey
+    }, null, 2), {
+        headers: {
+            "Content-Type": "application/json"
+        }
+    });
+};
+exports.createWebhookStore = __webpack_exports__.createWebhookStore;
+exports.handleWebhookInvoke = __webpack_exports__.handleWebhookInvoke;
+exports.handleWebhooksApi = __webpack_exports__.handleWebhooksApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWebhookStore",
+    "handleWebhookInvoke",
+    "handleWebhooksApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/http/webhooks.d.ts

@@ -0,0 +1,22 @@
+import type { GatewayHttpContext } from "./types.js";
+export type WebhookConfig = {
+    id: string;
+    name: string;
+    agentId: string;
+    secret: string;
+    enabled: boolean;
+    eventLabel?: string;
+    preset?: string;
+    sessionId?: string;
+    createdAt: number;
+    lastTriggeredAt?: number;
+};
+type WebhookStore = {
+    load: () => WebhookConfig[];
+    save: (webhooks: WebhookConfig[]) => void;
+    generateSecret: () => string;
+};
+export declare const createWebhookStore: (resolveConfigDirPath: () => string) => WebhookStore;
+export declare const handleWebhooksApi: (ctx: GatewayHttpContext, store: WebhookStore, req: Request, url: URL) => Promise<Response | null>;
+export declare const handleWebhookInvoke: (ctx: GatewayHttpContext, store: WebhookStore, req: Request, url: URL) => Promise<Response | null>;
+export {};

package/dist/gateway/http/webhooks.js

@@ -0,0 +1,313 @@
+import { AgentInvoker } from "../../cli/core/agentInvoker.js";
+import { OutputManager } from "../../cli/core/outputManager.js";
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const WEBHOOK_PRESETS = new Set([
+    "gog-gmail"
+]);
+const normalizePreset = (value)=>{
+    if (!value) return;
+    const trimmed = value.trim();
+    if (!trimmed || "custom" === trimmed) return;
+    return WEBHOOK_PRESETS.has(trimmed) ? trimmed : void 0;
+};
+const formatGogGmailContent = (payload, webhookName, eventLabel)=>{
+    const payloadMessages = Array.isArray(payload?.messages) ? payload.messages : [];
+    const dataMessages = Array.isArray(payload?.data?.messages) ? payload.data.messages : [];
+    const candidate = payload?.message || payload?.email || payload?.data?.message || payloadMessages[0] || dataMessages[0] || null;
+    const header = `Gmail update received${eventLabel ? ` (${eventLabel})` : ""} for "${webhookName}".`;
+    if (!candidate) {
+        const fallback = payload ? JSON.stringify(payload, null, 2) : "{}";
+        return `${header}\n\nPayload:\n${fallback}`;
+    }
+    const subject = candidate.subject || candidate.headers?.subject || candidate.headers?.Subject || "(no subject)";
+    const from = candidate.from || candidate.headers?.from || candidate.headers?.From || "unknown sender";
+    const snippet = candidate.snippet || candidate.preview || "";
+    const body = candidate.body || candidate.text || candidate.html || "";
+    const id = candidate.id || candidate.messageId || "";
+    const lines = [
+        header,
+        `From: ${from}`,
+        `Subject: ${subject}`
+    ];
+    if (id) lines.push(`Message ID: ${id}`);
+    if (snippet) lines.push(`Snippet: ${snippet}`);
+    if (body) lines.push("", body);
+    return lines.join("\n");
+};
+const createWebhookStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        return join(configDir, "webhooks.json");
+    };
+    return {
+        load: ()=>{
+            const path = resolvePath();
+            if (!existsSync(path)) return [];
+            try {
+                const raw = readFileSync(path, "utf-8");
+                const parsed = JSON.parse(raw);
+                return Array.isArray(parsed) ? parsed : [];
+            } catch  {
+                return [];
+            }
+        },
+        save: (webhooks)=>{
+            const path = resolvePath();
+            writeFileSync(path, JSON.stringify(webhooks, null, 2));
+        },
+        generateSecret: ()=>randomUUID().replace(/-/g, "") + randomUUID().replace(/-/g, "")
+    };
+};
+const agentExists = (ctx, agentId)=>{
+    const loader = new AgentLoader(ctx.configDir, ctx.workspace, ctx.getWingmanConfig());
+    const configs = loader.loadAllAgentConfigs();
+    return Boolean(configs.find((config)=>config.name === agentId));
+};
+const sessionExists = async (ctx, agentId, sessionId)=>{
+    const manager = await ctx.getSessionManager(agentId);
+    return Boolean(manager.getSession(sessionId));
+};
+const handleWebhooksApi = async (ctx, store, req, url)=>{
+    if ("/api/webhooks" === url.pathname) {
+        if ("GET" === req.method) {
+            const webhooks = store.load();
+            return new Response(JSON.stringify(webhooks, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("POST" === req.method) {
+            const body = await req.json();
+            const id = body?.id?.trim();
+            const name = body?.name?.trim();
+            const agentId = body?.agentId?.trim();
+            if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) return new Response("Invalid webhook id", {
+                status: 400
+            });
+            if (!name) return new Response("Webhook name required", {
+                status: 400
+            });
+            if (!agentId) return new Response("agentId required", {
+                status: 400
+            });
+            if (!agentExists(ctx, agentId)) return new Response("Invalid agentId", {
+                status: 400
+            });
+            const sessionId = body?.sessionId?.trim();
+            if (sessionId) {
+                const exists = await sessionExists(ctx, agentId, sessionId);
+                if (!exists) return new Response("Invalid sessionId", {
+                    status: 400
+                });
+            }
+            const webhooks = store.load();
+            if (webhooks.some((hook)=>hook.id === id)) return new Response("Webhook already exists", {
+                status: 409
+            });
+            const presetValue = normalizePreset(body?.preset);
+            if (body?.preset && !presetValue && "custom" !== body.preset.trim()) return new Response("Invalid preset", {
+                status: 400
+            });
+            const webhook = {
+                id,
+                name,
+                agentId,
+                secret: body?.secret?.trim() || store.generateSecret(),
+                enabled: body?.enabled ?? true,
+                eventLabel: body?.eventLabel?.trim() || void 0,
+                preset: presetValue,
+                sessionId: sessionId || void 0,
+                createdAt: Date.now()
+            };
+            webhooks.unshift(webhook);
+            store.save(webhooks);
+            return new Response(JSON.stringify(webhook, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const webhookMatch = url.pathname.match(/^\/api\/webhooks\/([^/]+)$/);
+    if (!webhookMatch) return null;
+    const webhookId = decodeURIComponent(webhookMatch[1]);
+    const webhooks = store.load();
+    const webhook = webhooks.find((hook)=>hook.id === webhookId);
+    if ("GET" === req.method) {
+        if (!webhook) return new Response("Webhook not found", {
+            status: 404
+        });
+        return new Response(JSON.stringify(webhook, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("PUT" === req.method) {
+        if (!webhook) return new Response("Webhook not found", {
+            status: 404
+        });
+        const body = await req.json();
+        const nextAgentId = body?.agentId?.trim() || webhook.agentId;
+        if (!agentExists(ctx, nextAgentId)) return new Response("Invalid agentId", {
+            status: 400
+        });
+        const hasPreset = Object.prototype.hasOwnProperty.call(body ?? {}, "preset");
+        const presetValue = hasPreset ? normalizePreset(body?.preset) : webhook.preset;
+        if (hasPreset && body?.preset && !presetValue && "custom" !== body.preset.trim()) return new Response("Invalid preset", {
+            status: 400
+        });
+        const hasSessionId = Object.prototype.hasOwnProperty.call(body ?? {}, "sessionId");
+        let nextSessionId = webhook.sessionId;
+        if (hasSessionId) {
+            const trimmed = body?.sessionId?.trim();
+            if (trimmed) {
+                const exists = await sessionExists(ctx, nextAgentId, trimmed);
+                if (!exists) return new Response("Invalid sessionId", {
+                    status: 400
+                });
+                nextSessionId = trimmed;
+            } else nextSessionId = void 0;
+        }
+        const updated = {
+            ...webhook,
+            name: body?.name?.trim() || webhook.name,
+            agentId: nextAgentId,
+            secret: body?.secret?.trim() || webhook.secret,
+            enabled: body?.enabled ?? webhook.enabled,
+            eventLabel: body?.eventLabel?.trim() || void 0,
+            preset: presetValue,
+            sessionId: nextSessionId
+        };
+        const nextWebhooks = webhooks.map((hook)=>hook.id === webhookId ? updated : hook);
+        store.save(nextWebhooks);
+        return new Response(JSON.stringify(updated, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        if (!webhook) return new Response("Webhook not found", {
+            status: 404
+        });
+        const nextWebhooks = webhooks.filter((hook)=>hook.id !== webhookId);
+        store.save(nextWebhooks);
+        return new Response(JSON.stringify({
+            ok: true
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+const handleWebhookInvoke = async (ctx, store, req, url)=>{
+    const match = url.pathname.match(/^\/webhooks\/([^/]+)$/);
+    if (!match) return null;
+    if ("POST" !== req.method) return new Response("Method Not Allowed", {
+        status: 405
+    });
+    const webhookId = decodeURIComponent(match[1]);
+    const webhooks = store.load();
+    const webhook = webhooks.find((hook)=>hook.id === webhookId);
+    if (!webhook) return new Response("Webhook not found", {
+        status: 404
+    });
+    if (!webhook.enabled) return new Response("Webhook disabled", {
+        status: 403
+    });
+    const secret = req.headers.get("x-wingman-secret") || url.searchParams.get("secret") || "";
+    if (!secret || secret !== webhook.secret) return new Response("Unauthorized", {
+        status: 401
+    });
+    let body = null;
+    let rawText = null;
+    try {
+        body = await req.json();
+    } catch  {
+        try {
+            rawText = await req.text();
+        } catch  {
+            rawText = null;
+        }
+    }
+    const eventLabel = "string" == typeof body?.event ? body.event : webhook.eventLabel;
+    const directPrompt = "string" == typeof body?.prompt ? body.prompt : "string" == typeof body?.content ? body.content : "string" == typeof body?.message ? body.message : "";
+    const payloadText = rawText || (null != body ? JSON.stringify(body, null, 2) : "");
+    const content = directPrompt || ("gog-gmail" === webhook.preset ? formatGogGmailContent(body ?? {}, webhook.name, eventLabel) : `Webhook "${webhook.name}" triggered${eventLabel ? ` (${eventLabel})` : ""}.\n\nPayload:\n${payloadText || "{}"}`);
+    const agentId = webhook.agentId;
+    const defaultSessionKey = `agent:${agentId}:webhook:${webhook.id}`;
+    let sessionKey = defaultSessionKey;
+    try {
+        const sessionManager = await ctx.getSessionManager(agentId);
+        sessionKey = webhook.sessionId || defaultSessionKey;
+        if (webhook.sessionId) {
+            const target = sessionManager.getSession(webhook.sessionId);
+            if (!target) return new Response("Target session not found", {
+                status: 404
+            });
+        } else sessionManager.getOrCreateSession(sessionKey, agentId, `Webhook: ${webhook.name}`);
+        sessionManager.updateSession(sessionKey, {
+            lastMessagePreview: content.substring(0, 200)
+        });
+        const existing = sessionManager.getSession(sessionKey);
+        if (existing) sessionManager.updateSession(sessionKey, {
+            messageCount: existing.messageCount + 1
+        });
+        sessionManager.updateSessionMetadata(sessionKey, {
+            source: "webhook",
+            webhookId: webhook.id,
+            webhookName: webhook.name,
+            eventLabel: eventLabel || void 0,
+            webhookPreset: webhook.preset
+        });
+        const outputManager = new OutputManager("interactive");
+        const workspace = ctx.resolveAgentWorkspace(agentId);
+        const session = sessionManager.getSession(sessionKey);
+        const workdir = session?.metadata?.workdir ?? null;
+        const defaultOutputDir = ctx.resolveDefaultOutputDir(agentId);
+        const invoker = new AgentInvoker({
+            workspace,
+            configDir: ctx.configDir,
+            outputManager,
+            logger: ctx.logger,
+            sessionManager,
+            workdir,
+            defaultOutputDir
+        });
+        invoker.invokeAgent(agentId, content, sessionKey);
+    } catch (error) {
+        ctx.logger.error("Webhook agent invocation failed", error);
+        return new Response("Webhook invocation failed", {
+            status: 500
+        });
+    }
+    const updatedWebhooks = webhooks.map((hook)=>hook.id === webhook.id ? {
+            ...hook,
+            lastTriggeredAt: Date.now()
+        } : hook);
+    store.save(updatedWebhooks);
+    return new Response(JSON.stringify({
+        ok: true,
+        sessionId: sessionKey
+    }, null, 2), {
+        headers: {
+            "Content-Type": "application/json"
+        }
+    });
+};
+export { createWebhookStore, handleWebhookInvoke, handleWebhooksApi };