@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/apps/daemon/dist/gateway/runtime.js

@@ -0,0 +1,850 @@
+import { createHash } from "node:crypto";
+import { createServer } from "node:http";
+import { encryptJson, } from "../../../../packages/shared/dist/index.js";
+import { admitMachineCreateSession, admitMachinePrompt } from "../relay/admission.js";
+import { sessions, sessionTurns } from "../state.js";
+import { createFeishuGatewayAdapter } from "./feishu.js";
+import { publicGatewayChannel, readGatewayStore, updateGatewayStore, } from "./store.js";
+const gatewayReplyHistoryLimit = 500;
+let gatewayServer;
+let gatewayRuntimeConfig;
+const gatewayAdapters = new Map();
+let gatewaySyncChain = Promise.resolve();
+function gatewayRuntimeEndpoint() {
+    return {
+        host: process.env.HAPPY_ELVES_GATEWAY_HOST || "127.0.0.1",
+        port: parseGatewayPort(process.env.HAPPY_ELVES_GATEWAY_PORT),
+    };
+}
+export async function startGatewayRuntime(config) {
+    gatewayRuntimeConfig = config;
+    await startGatewayDebugServer().catch((error) => {
+        gatewayServer = undefined;
+        console.error(`Gateway debug runtime failed to start: ${errorMessage(error)}`);
+    });
+    await syncGatewayRuntime(config);
+}
+async function startGatewayDebugServer() {
+    if (gatewayServer?.listening)
+        return;
+    const { host, port } = gatewayRuntimeEndpoint();
+    const server = createServer((request, response) => {
+        void handleGatewayHttpRequest(request, response).catch((error) => {
+            writeGatewayHttpJson(response, errorStatus(error), {
+                ok: false,
+                error: {
+                    code: errorCode(error),
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        });
+    });
+    gatewayServer = server;
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    console.log(`Gateway debug runtime listening on http://${host}:${port}`);
+}
+export async function stopGatewayRuntime() {
+    const server = gatewayServer;
+    gatewayServer = undefined;
+    gatewayRuntimeConfig = undefined;
+    const adapters = Array.from(gatewayAdapters.values());
+    gatewayAdapters.clear();
+    await Promise.allSettled(adapters.map((entry) => entry.adapter.stop()));
+    if (!server?.listening)
+        return;
+    await new Promise((resolve) => server.close(() => resolve()));
+}
+export async function syncGatewayRuntime(config = gatewayRuntimeConfig) {
+    if (!config)
+        return;
+    gatewayRuntimeConfig = config;
+    const run = gatewaySyncChain.then(async () => {
+        const store = await readGatewayStore();
+        const desired = new Set();
+        for (const channel of store.channels) {
+            if (channel.type !== "lark" || !channel.enabled)
+                continue;
+            desired.add(channel.id);
+            const key = gatewayAdapterKey(channel);
+            const existing = gatewayAdapters.get(channel.id);
+            if (existing?.key === key)
+                continue;
+            if (existing) {
+                gatewayAdapters.delete(channel.id);
+                await existing.adapter.stop().catch((error) => setGatewayLastError(channel.id, error));
+            }
+            if (!channel.appId || !channel.appSecret) {
+                await setGatewayLastError(channel.id, new Error("Lark gateway requires appId and appSecret"));
+                continue;
+            }
+            try {
+                const adapter = await createFeishuGatewayAdapter({
+                    config,
+                    channel,
+                    readChannel: async () => {
+                        const current = await readGatewayStore();
+                        return current.channels.find((item) => item.id === channel.id);
+                    },
+                    sendInbound: async (input) => {
+                        const currentStore = await readGatewayStore();
+                        const currentChannel = currentStore.channels.find((item) => item.id === input.gatewayId);
+                        if (!currentChannel?.enabled)
+                            return { accepted: false };
+                        if (!gatewayPolicyAllows(currentChannel, input)) {
+                            await setGatewayLastError(currentChannel.id, new Error("Gateway sender/chat is not allowed by channel policy"));
+                            return { accepted: false };
+                        }
+                        const delivery = await deliverGatewayMessage(config, currentChannel, {
+                            externalConversationId: gatewayConversationId(input.destination),
+                            externalMessageId: input.platformMessageId,
+                            text: input.text,
+                            destination: input.destination,
+                            senderPlatformUserId: input.senderPlatformUserId,
+                            senderDisplayName: input.senderDisplayName,
+                        });
+                        return { accepted: true, duplicate: delivery.duplicate, queued: delivery.queued };
+                    },
+                });
+                await adapter.start();
+                gatewayAdapters.set(channel.id, { key, adapter });
+                await clearGatewayLastError(channel.id);
+            }
+            catch (error) {
+                await setGatewayLastError(channel.id, error);
+            }
+        }
+        for (const [channelId, entry] of Array.from(gatewayAdapters.entries())) {
+            if (desired.has(channelId))
+                continue;
+            gatewayAdapters.delete(channelId);
+            await entry.adapter.stop().catch((error) => setGatewayLastError(channelId, error));
+        }
+        await retryPendingGatewayReplies();
+    });
+    gatewaySyncChain = run.catch(() => undefined);
+    await run;
+}
+async function handleGatewayHttpRequest(request, response) {
+    if (request.method === "GET" && request.url === "/health") {
+        writeGatewayHttpJson(response, 200, { ok: true, service: "happy-elves-gateway-daemon" });
+        return;
+    }
+    const { host, port } = gatewayRuntimeEndpoint();
+    const url = new URL(request.url ?? "/", `http://${host}:${port}`);
+    const match = /^\/gateway\/([^/]+)$/.exec(url.pathname);
+    if (request.method !== "POST" || !match) {
+        writeGatewayHttpJson(response, 404, { ok: false, error: { code: "NOT_FOUND", message: "Gateway route not found" } });
+        return;
+    }
+    if (!gatewayRuntimeConfig)
+        throw gatewayError("Gateway runtime is not configured", "GATEWAY_NOT_READY", 503);
+    const channelId = decodeURIComponent(match[1]);
+    const store = await readGatewayStore();
+    const channel = store.channels.find((item) => item.id === channelId);
+    if (!channel?.enabled)
+        throw gatewayError("Gateway channel is disabled or missing", "GATEWAY_DISABLED", 404);
+    const body = await readJsonRequestBody(request);
+    if (channel.type === "lark" && isLarkChallenge(body)) {
+        writeGatewayHttpJson(response, 200, { challenge: body.challenge });
+        return;
+    }
+    assertGatewayToken(channel, request, body);
+    const message = channel.type === "lark" ? larkMessageFromBody(body) : fakeGatewayMessageFromBody(body);
+    const delivery = await deliverGatewayMessage(gatewayRuntimeConfig, channel, message);
+    writeGatewayHttpJson(response, 200, { ok: true, type: "gateway.deliver", data: delivery });
+}
+export async function deliverGatewayMessage(config, channel, message) {
+    const externalConversationId = message.externalConversationId;
+    const externalMessageId = message.externalMessageId;
+    const requestId = stableGatewayId("gw_msg", channel.id, externalConversationId, externalMessageId);
+    const turnId = stableGatewayId("turn_gw", channel.id, externalConversationId, externalMessageId);
+    const receivedAt = new Date().toISOString();
+    await updateGatewayStore((current) => ({
+        ...current,
+        channels: current.channels.map((item) => item.id === channel.id
+            ? {
+                ...item,
+                lastReceived: {
+                    externalConversationId,
+                    externalMessageId,
+                    requestId,
+                    turnId,
+                    at: receivedAt,
+                },
+                updatedAt: receivedAt,
+            }
+            : item),
+    }));
+    let store = await readGatewayStore();
+    let mapping = store.mappings.find((item) => item.channelId === channel.id && item.externalConversationId === externalConversationId);
+    const createRequestId = stableGatewayId("gw_create", channel.id, externalConversationId);
+    if (!mapping) {
+        mapping = await createGatewayMapping(config, channel, externalConversationId, createRequestId);
+        store = await readGatewayStore();
+    }
+    const common = {
+        channelId: channel.id,
+        externalConversationId,
+        externalMessageId,
+        sessionId: mapping.sessionId,
+        requestId,
+        turnId,
+    };
+    if (store.replyHistory.some((item) => item.channelId === channel.id && item.requestId === requestId)) {
+        return { ...common, admission: "replayed", dispatch: "queued", duplicate: true };
+    }
+    if (store.pendingReplies.some((item) => item.channelId === channel.id && item.requestId === requestId)) {
+        return { ...common, admission: "replayed", dispatch: "queued", duplicate: true };
+    }
+    if (store.queue.some((item) => item.channelId === channel.id && item.requestId === requestId)) {
+        return { ...common, dispatch: "queued", queued: true, duplicate: true };
+    }
+    if (sessionTurns.activeTurnId(mapping.sessionId)) {
+        await enqueueGatewayMessage({
+            channel,
+            mapping,
+            externalConversationId,
+            externalMessageId,
+            requestId,
+            turnId,
+            text: message.text,
+            destination: message.destination,
+            senderPlatformUserId: message.senderPlatformUserId,
+            senderDisplayName: message.senderDisplayName,
+            at: receivedAt,
+        });
+        return { ...common, dispatch: "queued", queued: true };
+    }
+    return await admitGatewayPromptWithMappingRecovery(config, channel, mapping, {
+        ...common,
+        text: message.text,
+        destination: message.destination,
+        senderPlatformUserId: message.senderPlatformUserId,
+        senderDisplayName: message.senderDisplayName,
+    });
+}
+export async function notifyGatewayConversation(channel, input) {
+    if (!channel.enabled)
+        throw gatewayError("Gateway channel is disabled", "GATEWAY_DISABLED", 400);
+    const adapter = gatewayAdapters.get(channel.id)?.adapter;
+    if (!adapter)
+        throw gatewayError("Gateway adapter is not listening", "GATEWAY_NOT_LISTENING", 503);
+    const destination = destinationFromGatewayConversationId(input.externalConversationId);
+    const deliveryId = stableGatewayId("gw_notify", channel.id, input.externalConversationId, input.externalMessageId);
+    const result = await adapter.send({
+        deliveryId,
+        destination,
+        payload: {
+            type: "notice",
+            title: "Happy Elves",
+            text: input.text,
+            severity: "info",
+        },
+    });
+    const repliedAt = new Date().toISOString();
+    const lastReplied = {
+        externalConversationId: input.externalConversationId,
+        externalMessageId: input.externalMessageId,
+        deliveryId,
+        platformMessageId: result.platformMessageId,
+        at: repliedAt,
+    };
+    await updateGatewayStore((current) => ({
+        ...current,
+        channels: current.channels.map((item) => item.id === channel.id
+            ? { ...item, lastError: undefined, lastReplied, updatedAt: repliedAt }
+            : item),
+        replyHistory: [
+            {
+                channelId: channel.id,
+                externalConversationId: input.externalConversationId,
+                externalMessageId: input.externalMessageId,
+                deliveryId,
+                platformMessageId: result.platformMessageId,
+                repliedAt,
+            },
+            ...current.replyHistory.filter((item) => !(item.channelId === channel.id && item.deliveryId === deliveryId)),
+        ].slice(0, gatewayReplyHistoryLimit),
+    }));
+    return {
+        channelId: channel.id,
+        externalConversationId: input.externalConversationId,
+        externalMessageId: input.externalMessageId,
+        deliveryId,
+        platformMessageId: result.platformMessageId,
+        dispatch: "delivered",
+    };
+}
+export async function handleGatewayTurnTerminal(config, input) {
+    await deliverPendingGatewayReply(config, input);
+    await drainGatewayQueue(config, input.sessionId);
+}
+async function admitGatewayPromptWithMappingRecovery(config, channel, mapping, input) {
+    try {
+        return await admitGatewayPromptNow(config, channel, input);
+    }
+    catch (error) {
+        if (!canRecoverGatewayMapping(channel, error))
+            throw error;
+        const recovered = await recoverGatewayMapping(config, channel, mapping, input.externalConversationId, input.requestId);
+        return await admitGatewayPromptNow(config, channel, {
+            ...input,
+            sessionId: recovered.sessionId,
+        });
+    }
+}
+async function recoverGatewayMapping(config, channel, staleMapping, externalConversationId, recoverySeed) {
+    const createRequestId = stableGatewayId("gw_create", channel.id, externalConversationId, "recover", recoverySeed);
+    const sessionId = stableGatewayId("ses_gw", channel.id, externalConversationId, "recover", recoverySeed);
+    const mapping = await createGatewayMapping(config, channel, externalConversationId, createRequestId, sessionId);
+    if (mapping.sessionId === staleMapping.sessionId)
+        return mapping;
+    const now = new Date().toISOString();
+    await updateGatewayStore((current) => ({
+        ...current,
+        queue: current.queue.map((item) => item.channelId === channel.id && item.externalConversationId === externalConversationId
+            ? { ...item, sessionId: mapping.sessionId, updatedAt: now }
+            : item),
+    }));
+    return mapping;
+}
+function canRecoverGatewayMapping(channel, error) {
+    if (channel.targetSessionId)
+        return false;
+    if (!channel.targetCwd)
+        return false;
+    return errorCode(error) === "SESSION_NOT_FOUND" || errorCode(error) === "SESSION_CLOSED";
+}
+async function createGatewayMapping(config, channel, externalConversationId, createRequestId, recoveredSessionId) {
+    if (channel.targetSessionId) {
+        const now = new Date().toISOString();
+        const mapping = {
+            channelId: channel.id,
+            externalConversationId,
+            sessionId: channel.targetSessionId,
+            createRequestId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await updateGatewayStore((current) => ({
+            ...current,
+            mappings: [mapping, ...current.mappings.filter((item) => !(item.channelId === channel.id && item.externalConversationId === externalConversationId))],
+        }));
+        return mapping;
+    }
+    if (!channel.targetCwd)
+        throw gatewayError("Gateway channel needs target cwd or target session", "GATEWAY_TARGET_MISSING", 400);
+    const sessionId = recoveredSessionId ?? stableGatewayId("ses_gw", channel.id, externalConversationId);
+    const create = await admitMachineCreateSession(config, {
+        requestId: createRequestId,
+        sessionId,
+        agent: channel.defaultAgent,
+        cwd: channel.targetCwd,
+        name: `Gateway ${channel.type}: ${externalConversationId}`,
+        ...(channel.defaultModel ? { model: channel.defaultModel } : {}),
+        encryptedMetadata: await encryptJson(config.accountSecret, `gateway:create:${createRequestId}`, {
+            createdFrom: "gateway",
+            gateway: {
+                channelId: channel.id,
+                channelType: channel.type,
+                externalConversationId,
+            },
+            agent: channel.defaultAgent,
+            cwd: channel.targetCwd,
+            name: `Gateway ${channel.type}: ${externalConversationId}`,
+            ...(channel.defaultModel ? { model: channel.defaultModel } : {}),
+        }),
+    });
+    if (!create.sessionId)
+        throw gatewayError("Gateway session admission did not return a sessionId", "GATEWAY_CREATE_FAILED", 502);
+    const now = new Date().toISOString();
+    const mapping = {
+        channelId: channel.id,
+        externalConversationId,
+        sessionId: create.sessionId,
+        createRequestId,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await updateGatewayStore((current) => ({
+        ...current,
+        mappings: [mapping, ...current.mappings.filter((item) => !(item.channelId === channel.id && item.externalConversationId === externalConversationId))],
+    }));
+    return mapping;
+}
+async function admitGatewayPromptNow(config, channel, input) {
+    const deliveryId = stableGatewayId("gw_delivery", channel.id, input.externalConversationId, input.externalMessageId, input.requestId);
+    const admittedAt = new Date().toISOString();
+    if (input.destination) {
+        await upsertPendingReply({
+            channelId: channel.id,
+            externalConversationId: input.externalConversationId,
+            externalMessageId: input.externalMessageId,
+            sessionId: input.sessionId,
+            requestId: input.requestId,
+            turnId: input.turnId,
+            deliveryId,
+            destination: input.destination,
+            status: "pending",
+            attempts: 0,
+            createdAt: admittedAt,
+            updatedAt: admittedAt,
+        });
+    }
+    try {
+        const sent = await admitMachinePrompt(config, {
+            requestId: input.requestId,
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            encryptedPrompt: await encryptJson(config.accountSecret, `gateway:prompt:${input.sessionId}:${input.turnId}`, {
+                type: "user_prompt",
+                text: input.text,
+            }),
+            permissionMode: "approve-reads",
+            ...(channel.defaultModel ? { model: channel.defaultModel } : {}),
+        });
+        const turnId = sent.turnId ?? input.turnId;
+        const lastAdmitted = {
+            externalConversationId: input.externalConversationId,
+            externalMessageId: input.externalMessageId,
+            requestId: input.requestId,
+            sessionId: input.sessionId,
+            turnId,
+            deliveryId,
+            at: admittedAt,
+        };
+        await updateGatewayStore((current) => ({
+            ...current,
+            channels: current.channels.map((item) => item.id === channel.id ? {
+                ...item,
+                lastError: undefined,
+                lastAdmitted,
+                lastDeliveredMessage: {
+                    externalConversationId: input.externalConversationId,
+                    externalMessageId: input.externalMessageId,
+                    requestId: input.requestId,
+                    sessionId: input.sessionId,
+                    turnId,
+                    deliveredAt: admittedAt,
+                },
+                updatedAt: admittedAt,
+            } : item),
+            mappings: current.mappings.map((item) => item.channelId === channel.id && item.externalConversationId === input.externalConversationId
+                ? { ...item, sessionId: input.sessionId, updatedAt: admittedAt }
+                : item),
+            queue: current.queue.filter((item) => !(item.channelId === channel.id && item.requestId === input.requestId)),
+            pendingReplies: sent.admission === "replayed" && !current.pendingReplies.some((item) => item.channelId === channel.id && item.requestId === input.requestId)
+                ? current.pendingReplies.filter((item) => !(item.channelId === channel.id && item.requestId === input.requestId))
+                : current.pendingReplies,
+        }));
+        return {
+            channelId: channel.id,
+            externalConversationId: input.externalConversationId,
+            externalMessageId: input.externalMessageId,
+            sessionId: input.sessionId,
+            requestId: input.requestId,
+            turnId,
+            admission: sent.admission,
+            dispatch: sent.dispatch,
+            duplicate: sent.admission === "replayed",
+        };
+    }
+    catch (error) {
+        await updateGatewayStore((current) => ({
+            ...current,
+            pendingReplies: current.pendingReplies.filter((item) => !(item.channelId === channel.id && item.requestId === input.requestId && !item.payload)),
+            channels: current.channels.map((item) => item.id === channel.id
+                ? { ...item, lastError: errorMessage(error), updatedAt: new Date().toISOString() }
+                : item),
+        }));
+        throw error;
+    }
+}
+async function upsertPendingReply(reply) {
+    await updateGatewayStore((current) => ({
+        ...current,
+        pendingReplies: [
+            {
+                ...reply,
+                ...(current.pendingReplies.find((item) => item.channelId === reply.channelId && item.requestId === reply.requestId) ?? {}),
+                ...reply,
+            },
+            ...current.pendingReplies.filter((item) => !(item.channelId === reply.channelId && item.requestId === reply.requestId)),
+        ],
+    }));
+}
+async function enqueueGatewayMessage(input) {
+    const queued = {
+        channelId: input.channel.id,
+        externalConversationId: input.externalConversationId,
+        externalMessageId: input.externalMessageId,
+        sessionId: input.mapping.sessionId,
+        requestId: input.requestId,
+        turnId: input.turnId,
+        text: input.text,
+        destination: input.destination,
+        senderPlatformUserId: input.senderPlatformUserId,
+        senderDisplayName: input.senderDisplayName,
+        queuedAt: input.at,
+        updatedAt: input.at,
+    };
+    await updateGatewayStore((current) => ({
+        ...current,
+        queue: [queued, ...current.queue.filter((item) => !(item.channelId === input.channel.id && item.requestId === input.requestId))],
+    }));
+}
+async function drainGatewayQueue(config, sessionId) {
+    const store = await readGatewayStore();
+    const admittedSessions = new Set();
+    const queued = [...store.queue].sort((a, b) => a.queuedAt.localeCompare(b.queuedAt));
+    for (const item of queued) {
+        if (sessionId && item.sessionId !== sessionId)
+            continue;
+        if (admittedSessions.has(item.sessionId))
+            continue;
+        if (sessionTurns.activeTurnId(item.sessionId))
+            continue;
+        const channel = store.channels.find((candidate) => candidate.id === item.channelId);
+        if (!channel?.enabled)
+            continue;
+        try {
+            const mapping = {
+                channelId: channel.id,
+                externalConversationId: item.externalConversationId,
+                sessionId: item.sessionId,
+                createRequestId: stableGatewayId("gw_create", channel.id, item.externalConversationId),
+                createdAt: item.queuedAt,
+                updatedAt: item.updatedAt,
+            };
+            await admitGatewayPromptWithMappingRecovery(config, channel, mapping, {
+                externalConversationId: item.externalConversationId,
+                externalMessageId: item.externalMessageId,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                turnId: item.turnId,
+                text: item.text,
+                destination: item.destination,
+                senderPlatformUserId: item.senderPlatformUserId,
+                senderDisplayName: item.senderDisplayName,
+            });
+            admittedSessions.add(item.sessionId);
+        }
+        catch (error) {
+            await setGatewayLastError(item.channelId, error);
+            break;
+        }
+    }
+}
+async function deliverPendingGatewayReply(config, input) {
+    const store = await readGatewayStore();
+    const pending = store.pendingReplies.find((item) => item.sessionId === input.sessionId
+        && (item.turnId === input.turnId || (input.requestId && item.requestId === input.requestId)));
+    if (!pending)
+        return;
+    const payload = gatewayTerminalPayload(config, input);
+    await updateGatewayStore((current) => ({
+        ...current,
+        pendingReplies: current.pendingReplies.map((item) => item.channelId === pending.channelId && item.requestId === pending.requestId
+            ? { ...item, payload, updatedAt: new Date().toISOString() }
+            : item),
+    }));
+    await sendPendingGatewayReply({ ...pending, payload });
+}
+async function retryPendingGatewayReplies() {
+    const store = await readGatewayStore();
+    const now = Date.now();
+    for (const pending of store.pendingReplies) {
+        if (!pending.payload || pending.status !== "pending")
+            continue;
+        if (pending.nextAttemptAt && Date.parse(pending.nextAttemptAt) > now)
+            continue;
+        await sendPendingGatewayReply(pending);
+    }
+}
+async function sendPendingGatewayReply(pending) {
+    if (!pending.destination || !pending.payload)
+        return;
+    const channel = (await readGatewayStore()).channels.find((item) => item.id === pending.channelId);
+    if (!channel?.enabled)
+        return;
+    const adapter = gatewayAdapters.get(channel.id)?.adapter;
+    if (!adapter) {
+        await markPendingReplyFailed(pending, new Error("Gateway adapter is not listening"));
+        return;
+    }
+    try {
+        const result = await adapter.send({
+            deliveryId: pending.deliveryId,
+            destination: pending.destination,
+            payload: pending.payload,
+        });
+        const repliedAt = new Date().toISOString();
+        const lastReplied = {
+            externalConversationId: pending.externalConversationId,
+            externalMessageId: pending.externalMessageId,
+            requestId: pending.requestId,
+            sessionId: pending.sessionId,
+            turnId: pending.turnId,
+            deliveryId: pending.deliveryId,
+            platformMessageId: result.platformMessageId,
+            at: repliedAt,
+        };
+        await updateGatewayStore((current) => ({
+            ...current,
+            channels: current.channels.map((item) => item.id === pending.channelId
+                ? { ...item, lastError: undefined, lastReplied, updatedAt: repliedAt }
+                : item),
+            pendingReplies: current.pendingReplies.filter((item) => !(item.channelId === pending.channelId && item.requestId === pending.requestId)),
+            replyHistory: [
+                {
+                    channelId: pending.channelId,
+                    externalConversationId: pending.externalConversationId,
+                    externalMessageId: pending.externalMessageId,
+                    sessionId: pending.sessionId,
+                    requestId: pending.requestId,
+                    turnId: pending.turnId,
+                    deliveryId: pending.deliveryId,
+                    platformMessageId: result.platformMessageId,
+                    repliedAt,
+                },
+                ...current.replyHistory.filter((item) => !(item.channelId === pending.channelId && item.requestId === pending.requestId)),
+            ].slice(0, gatewayReplyHistoryLimit),
+        }));
+    }
+    catch (error) {
+        await markPendingReplyFailed(pending, error);
+        console.error(`Gateway reply failed for ${pending.channelId}/${pending.turnId}: ${errorMessage(error)}`);
+    }
+}
+async function markPendingReplyFailed(pending, error) {
+    const now = new Date();
+    const attempts = pending.attempts + 1;
+    const nextAttemptAt = new Date(now.getTime() + Math.min(60_000, 2 ** Math.min(attempts, 6) * 1000)).toISOString();
+    await updateGatewayStore((current) => ({
+        ...current,
+        channels: current.channels.map((item) => item.id === pending.channelId
+            ? { ...item, lastError: errorMessage(error), updatedAt: now.toISOString() }
+            : item),
+        pendingReplies: current.pendingReplies.map((item) => item.channelId === pending.channelId && item.requestId === pending.requestId
+            ? { ...item, attempts, lastError: errorMessage(error), nextAttemptAt, updatedAt: now.toISOString() }
+            : item),
+    }));
+}
+function gatewayTerminalPayload(config, input) {
+    const session = sessions.get(input.sessionId);
+    return {
+        type: "turn_stopped",
+        sessionId: input.sessionId,
+        machineId: config.machineId,
+        turnId: input.turnId,
+        status: input.status,
+        stopReason: input.stopReason,
+        error: input.error,
+        outputPreview: input.outputPreview ? truncateGatewayText(input.outputPreview, 4000) : undefined,
+        sessionName: session?.name,
+    };
+}
+export async function setGatewayLastError(channelId, error) {
+    const message = errorMessage(error);
+    await updateGatewayStore((current) => ({
+        ...current,
+        channels: current.channels.map((channel) => channel.id === channelId
+            ? { ...channel, lastError: message, updatedAt: new Date().toISOString() }
+            : channel),
+    }));
+}
+async function clearGatewayLastError(channelId) {
+    await updateGatewayStore((current) => ({
+        ...current,
+        channels: current.channels.map((channel) => channel.id === channelId
+            ? { ...channel, lastError: undefined, updatedAt: new Date().toISOString() }
+            : channel),
+    }));
+}
+export function publicChannelsForStore(store) {
+    return store.channels.map((channel) => publicGatewayChannel(channel, gatewayChannelListening(channel)));
+}
+function gatewayChannelListening(channel) {
+    if (!channel.enabled)
+        return false;
+    if (channel.type === "lark")
+        return gatewayAdapters.has(channel.id);
+    return Boolean(gatewayServer?.listening);
+}
+function gatewayConversationId(destination) {
+    if (destination.contextKind === "thread")
+        return `${destination.platformChatId}:thread:${destination.contextKey}`;
+    return `${destination.platformChatId}:main`;
+}
+function destinationFromGatewayConversationId(externalConversationId) {
+    const threadMatch = /^(.+):thread:(.+)$/.exec(externalConversationId);
+    if (threadMatch) {
+        return { platformChatId: threadMatch[1], contextKind: "thread", contextKey: threadMatch[2] };
+    }
+    const mainMatch = /^(.+):main$/.exec(externalConversationId);
+    if (mainMatch)
+        return { platformChatId: mainMatch[1], contextKind: "main" };
+    throw gatewayError("Gateway notify requires a conversation id like <chatId>:main or <chatId>:thread:<threadId>", "GATEWAY_CONVERSATION_INVALID", 400);
+}
+function gatewayAdapterKey(channel) {
+    return JSON.stringify({
+        type: channel.type,
+        enabled: channel.enabled,
+        appId: channel.appId,
+        appSecretHash: channel.appSecret ? createHash("sha256").update(channel.appSecret).digest("base64url") : "",
+        domain: channel.domain ?? "feishu",
+        inboundMode: channel.inboundMode,
+        processingReaction: channel.processingReaction,
+        allowAnySender: channel.allowAnySender ?? true,
+        allowedChatIds: channel.allowedChatIds ?? [],
+        allowedSenderIds: channel.allowedSenderIds ?? [],
+    });
+}
+function gatewayPolicyAllows(channel, input) {
+    if (channel.allowAnySender ?? true)
+        return true;
+    const chatId = input.destination?.platformChatId;
+    if (chatId && (channel.allowedChatIds ?? []).includes(chatId))
+        return true;
+    if (input.senderPlatformUserId && (channel.allowedSenderIds ?? []).includes(input.senderPlatformUserId))
+        return true;
+    return false;
+}
+function stableGatewayId(prefix, ...parts) {
+    const hash = createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 32);
+    return `${prefix}_${hash}`;
+}
+function parseGatewayPort(value) {
+    const port = Number(value || "8789");
+    if (Number.isInteger(port) && port >= 1 && port <= 65_535)
+        return port;
+    return 8789;
+}
+async function readJsonRequestBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 1024 * 1024)
+            throw gatewayError("Gateway request body is too large", "REQUEST_TOO_LARGE", 413);
+        chunks.push(buffer);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+    }
+    catch {
+        throw gatewayError("Gateway request body must be JSON", "INVALID_JSON", 400);
+    }
+}
+function writeGatewayHttpJson(response, statusCode, body) {
+    response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+    response.end(`${JSON.stringify(body)}\n`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isLarkChallenge(value) {
+    return isRecord(value) && typeof value.challenge === "string";
+}
+function assertGatewayToken(channel, request, body) {
+    if (!channel.localToken)
+        return;
+    const auth = request.headers.authorization;
+    const bearer = typeof auth === "string" && auth.startsWith("Bearer ") ? auth.slice("Bearer ".length) : undefined;
+    const record = isRecord(body) ? body : {};
+    const header = isRecord(record.header) ? record.header : {};
+    const token = bearer ?? stringField(record, "token") ?? stringField(header, "token") ?? headerValue(request, "x-happy-elves-token");
+    if (token !== channel.localToken)
+        throw gatewayError("Gateway token is invalid", "GATEWAY_TOKEN_INVALID", 401);
+}
+function headerValue(request, key) {
+    const value = request.headers[key.toLowerCase()];
+    return typeof value === "string" ? value : undefined;
+}
+function fakeGatewayMessageFromBody(body) {
+    const record = isRecord(body) ? body : {};
+    const externalConversationId = stringField(record, "externalConversationId") ?? stringField(record, "conversationId");
+    const externalMessageId = stringField(record, "externalMessageId") ?? stringField(record, "messageId");
+    const text = stringField(record, "text");
+    if (!externalConversationId || !externalMessageId || !text) {
+        throw gatewayError("Fake gateway body requires conversationId, messageId, and text", "GATEWAY_MESSAGE_INVALID", 400);
+    }
+    return { externalConversationId, externalMessageId, text };
+}
+function larkMessageFromBody(body) {
+    const record = isRecord(body) ? body : {};
+    const event = isRecord(record.event) ? record.event : record;
+    const message = isRecord(event.message) ? event.message : event;
+    const sender = isRecord(event.sender) ? event.sender : {};
+    const senderId = isRecord(sender.sender_id) ? sender.sender_id : {};
+    const externalMessageId = stringField(message, "message_id") ?? stringField(event, "message_id") ?? stringField(record, "uuid");
+    const chatId = stringField(message, "chat_id") ??
+        stringField(event, "chat_id") ??
+        stringField(event, "open_chat_id") ??
+        stringField(senderId, "open_id");
+    const text = larkTextFromContent(message.content) ?? stringField(message, "text");
+    if (!chatId || !externalMessageId || !text) {
+        throw gatewayError("Lark gateway event is not a supported text message", "GATEWAY_MESSAGE_INVALID", 400);
+    }
+    const threadId = stringField(message, "thread_id");
+    const destination = threadId
+        ? { platformChatId: chatId, contextKind: "thread", contextKey: threadId, replyToMessageId: externalMessageId }
+        : { platformChatId: chatId, contextKind: "main", replyToMessageId: externalMessageId };
+    return {
+        externalConversationId: gatewayConversationId(destination),
+        externalMessageId,
+        text,
+        destination,
+    };
+}
+function larkTextFromContent(content) {
+    if (typeof content === "string") {
+        try {
+            const parsed = JSON.parse(content);
+            if (isRecord(parsed))
+                return stringField(parsed, "text");
+        }
+        catch {
+            return content;
+        }
+    }
+    if (isRecord(content))
+        return stringField(content, "text");
+    return undefined;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function truncateGatewayText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, maxChars - 1)}…`;
+}
+function gatewayError(message, code, statusCode) {
+    const error = new Error(message);
+    error.code = code;
+    error.statusCode = statusCode;
+    return error;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function errorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string"
+        ? error.code
+        : "GATEWAY_REQUEST_FAILED";
+}
+function errorStatus(error) {
+    return typeof error === "object" && error !== null && "statusCode" in error && typeof error.statusCode === "number"
+        ? error.statusCode
+        : 500;
+}
+//# sourceMappingURL=runtime.js.map