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

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

@@ -0,0 +1,493 @@
+import { formatGatewayPayload } from "./format.js";
+const feishuProcessingReactionEmoji = "Typing";
+const maxTrackedProcessingReactions = 200;
+export async function createFeishuGatewayAdapter(context) {
+    if (!context.channel.appId || !context.channel.appSecret) {
+        throw new Error(`Gateway ${context.channel.id} is missing Feishu appId/appSecret`);
+    }
+    const lark = await import("@larksuiteoapi/node-sdk");
+    const baseConfig = {
+        appId: context.channel.appId,
+        appSecret: context.channel.appSecret,
+    };
+    const domain = context.channel.domain === "lark" ? lark.Domain?.Lark : lark.Domain?.Feishu;
+    if (domain)
+        baseConfig.domain = domain;
+    const client = new lark.Client(baseConfig);
+    const processingReactions = createFeishuProcessingReactionRegistry(client);
+    const botOpenIdResolver = createFeishuBotOpenIdResolver(client);
+    const wsClient = new lark.WSClient({
+        ...baseConfig,
+        ...(lark.LoggerLevel?.warn ? { loggerLevel: lark.LoggerLevel.warn } : {}),
+    });
+    const dispatcher = new lark.EventDispatcher({}).register({
+        "im.message.receive_v1": async (data) => {
+            const inbound = normalizeFeishuMessage(data);
+            if (!inbound)
+                return;
+            const channel = await context.readChannel();
+            if (!channel?.enabled)
+                return;
+            const botIdentity = channel.inboundMode === "mention"
+                ? await botOpenIdResolver.get() ?? { appId: channel.appId }
+                : undefined;
+            if (!shouldHandleFeishuInbound(channel, inbound, botIdentity))
+                return;
+            const startedReaction = await processingReactions.start(inbound.platformMessageId, channel.processingReaction);
+            try {
+                const result = await context.sendInbound({
+                    gatewayId: channel.id,
+                    platform: "feishu",
+                    platformEventId: inbound.platformEventId,
+                    platformMessageId: inbound.platformMessageId,
+                    senderPlatformUserId: inbound.senderPlatformUserId,
+                    ...(inbound.senderDisplayName ? { senderDisplayName: inbound.senderDisplayName } : {}),
+                    destination: inbound.destination,
+                    text: stripFeishuBotMention(inbound.text, inbound.mentions, botIdentity),
+                });
+                if (shouldCompleteProcessingReaction(result, { startedReaction }))
+                    await processingReactions.complete(inbound.platformMessageId);
+            }
+            catch (error) {
+                await processingReactions.complete(inbound.platformMessageId);
+                throw error;
+            }
+        },
+    });
+    return {
+        async start() {
+            await wsClient.start({ eventDispatcher: dispatcher });
+        },
+        async stop() {
+            if (wsClient.stop)
+                await wsClient.stop();
+            else if (wsClient.close)
+                await wsClient.close();
+            await processingReactions.clear();
+        },
+        async send(input) {
+            const text = formatGatewayPayload(input.payload);
+            try {
+                const response = await sendFeishuText(client, input.destination, text, input.deliveryId);
+                return { platformMessageId: platformMessageId(response) };
+            }
+            finally {
+                if (input.destination.replyToMessageId) {
+                    await processingReactions.complete(input.destination.replyToMessageId);
+                }
+            }
+        },
+    };
+}
+export function shouldCompleteProcessingReaction(result, input = {}) {
+    return !result.accepted && (!result.duplicate || input.startedReaction === true);
+}
+export function createFeishuProcessingReactionTracker(client, input = {}) {
+    const emojiType = input.emojiType ?? feishuProcessingReactionEmoji;
+    const maxTracked = Math.max(1, input.maxTracked ?? maxTrackedProcessingReactions);
+    const now = input.now ?? Date.now;
+    const pending = new Map();
+    async function start(messageId) {
+        if (!messageId || pending.has(messageId))
+            return false;
+        await trimPending();
+        const api = reactionApi(client);
+        if (!api?.create)
+            return false;
+        try {
+            const response = await api.create({
+                path: { message_id: messageId },
+                data: { reaction_type: { emoji_type: emojiType } },
+            });
+            const reactionId = platformReactionId(response);
+            if (reactionId) {
+                pending.set(messageId, { reactionId, createdAt: now() });
+                return true;
+            }
+        }
+        catch {
+            // Reaction status is best-effort UI feedback; never block gateway processing.
+        }
+        return false;
+    }
+    async function complete(messageId) {
+        const tracked = pending.get(messageId);
+        if (!tracked)
+            return;
+        const api = reactionApi(client);
+        if (!api?.delete) {
+            pending.delete(messageId);
+            return;
+        }
+        try {
+            await api.delete({ path: { message_id: messageId, reaction_id: tracked.reactionId } });
+            pending.delete(messageId);
+        }
+        catch {
+            // Keep the handle so a later clear/complete can retry the deletion.
+        }
+    }
+    async function clear() {
+        for (const messageId of Array.from(pending.keys())) {
+            await complete(messageId);
+        }
+    }
+    async function trimPending() {
+        while (pending.size >= maxTracked) {
+            const oldest = oldestPendingMessageId(pending);
+            if (!oldest)
+                return;
+            await complete(oldest);
+            if (pending.has(oldest))
+                pending.delete(oldest);
+        }
+    }
+    return { start, complete, clear, pendingCount: () => pending.size };
+}
+function createFeishuBotOpenIdResolver(client) {
+    let cached;
+    let inflight;
+    async function get() {
+        if (cached)
+            return cached;
+        if (inflight)
+            return await inflight;
+        inflight = resolveFeishuBotIdentity(client)
+            .then((identity) => {
+            if (identity && Object.keys(identity).length > 0)
+                cached = identity;
+            return identity;
+        })
+            .catch(() => undefined)
+            .finally(() => {
+            inflight = undefined;
+        });
+        return await inflight;
+    }
+    return { get, cached: () => cached };
+}
+function createFeishuProcessingReactionRegistry(client) {
+    const trackers = new Map();
+    function trackerFor(emojiType) {
+        const key = emojiType || feishuProcessingReactionEmoji;
+        const existing = trackers.get(key);
+        if (existing)
+            return existing;
+        const tracker = createFeishuProcessingReactionTracker(client, { emojiType: key });
+        trackers.set(key, tracker);
+        return tracker;
+    }
+    return {
+        async start(messageId, config) {
+            if (!config.enabled)
+                return false;
+            return await trackerFor(config.emojiType).start(messageId);
+        },
+        async complete(messageId) {
+            for (const tracker of trackers.values())
+                await tracker.complete(messageId);
+        },
+        async clear() {
+            for (const tracker of trackers.values())
+                await tracker.clear();
+            trackers.clear();
+        },
+    };
+}
+export function normalizeFeishuMessage(data) {
+    const record = asRecord(data);
+    if (!record)
+        return undefined;
+    const event = asRecord(record.event) ?? record;
+    const message = asRecord(event.message);
+    if (!message)
+        return undefined;
+    const chatId = stringField(message, "chat_id");
+    const messageId = stringField(message, "message_id");
+    if (!chatId || !messageId)
+        return undefined;
+    const sender = asRecord(event.sender);
+    const senderId = asRecord(sender?.sender_id);
+    const senderPlatformUserId = stringField(senderId, "open_id") ??
+        stringField(senderId, "union_id") ??
+        stringField(senderId, "user_id") ??
+        stringField(sender, "sender_id") ??
+        "unknown";
+    const threadId = stringField(message, "thread_id");
+    const chatType = stringField(message, "chat_type");
+    const text = feishuContentText(message.content);
+    if (!text.trim())
+        return undefined;
+    const eventId = stringField(asRecord(record.header), "event_id") ?? stringField(record, "event_id") ?? messageId;
+    const destination = threadId
+        ? {
+            platformChatId: chatId,
+            contextKind: "thread",
+            contextKey: threadId,
+            replyToMessageId: messageId,
+        }
+        : {
+            platformChatId: chatId,
+            contextKind: "main",
+            replyToMessageId: messageId,
+        };
+    return {
+        platformEventId: eventId,
+        platformMessageId: messageId,
+        senderPlatformUserId,
+        senderDisplayName: stringField(sender, "sender_type"),
+        destination,
+        text,
+        ...(chatType ? { chatType } : {}),
+        mentions: feishuMentions(message),
+    };
+}
+export function shouldHandleFeishuInbound(profile, inbound, botIdentity) {
+    if (profile.inboundMode === "all")
+        return true;
+    if (isFeishuDirectChat(inbound.chatType))
+        return true;
+    const identity = normalizeBotIdentity(botIdentity);
+    if (!identity)
+        return false;
+    return inbound.mentions.some((mention) => (identity.openId && mention.openId === identity.openId)
+        || (identity.unionId && mention.unionId === identity.unionId)
+        || (identity.userId && mention.userId === identity.userId)
+        || (identity.appId && mention.appId === identity.appId));
+}
+export async function sendFeishuText(client, destination, text, deliveryId) {
+    const content = JSON.stringify({ text });
+    const messageApi = client.im?.v1?.message ?? client.im?.message;
+    if (!messageApi?.create)
+        throw new Error("Feishu SDK message.create is unavailable");
+    const errors = [];
+    if (destination.replyToMessageId && messageApi.reply) {
+        try {
+            return await messageApi.reply({
+                path: { message_id: destination.replyToMessageId },
+                data: {
+                    msg_type: "text",
+                    content,
+                    ...(deliveryId ? { uuid: deliveryId } : {}),
+                },
+            });
+        }
+        catch (error) {
+            errors.push(errorMessage(error));
+        }
+    }
+    if (destination.contextKind === "thread") {
+        if (destination.contextKey) {
+            try {
+                return await messageApi.create({
+                    params: { receive_id_type: "thread_id" },
+                    data: {
+                        receive_id: destination.contextKey,
+                        msg_type: "text",
+                        content,
+                        ...(deliveryId ? { uuid: deliveryId } : {}),
+                    },
+                });
+            }
+            catch (error) {
+                errors.push(errorMessage(error));
+            }
+        }
+        throw new Error(`Feishu thread delivery failed${errors.length > 0 ? `: ${errors.join("; ")}` : ""}`);
+    }
+    try {
+        return await messageApi.create({
+            params: { receive_id_type: "chat_id" },
+            data: {
+                receive_id: destination.platformChatId,
+                msg_type: "text",
+                content,
+                ...(deliveryId ? { uuid: deliveryId } : {}),
+            },
+        });
+    }
+    catch (error) {
+        errors.push(errorMessage(error));
+        throw new Error(`Feishu chat delivery failed: ${errors.join("; ")}`);
+    }
+}
+export function stripFeishuBotMention(text, mentions, botIdentity) {
+    const identity = normalizeBotIdentity(botIdentity);
+    if (!identity)
+        return text;
+    const botKeys = mentions
+        .filter((mention) => (identity.openId && mention.openId === identity.openId)
+        || (identity.unionId && mention.unionId === identity.unionId)
+        || (identity.userId && mention.userId === identity.userId)
+        || (identity.appId && mention.appId === identity.appId))
+        .map((mention) => mention.key)
+        .filter((key) => Boolean(key));
+    let stripped = text;
+    for (const key of botKeys) {
+        stripped = stripped.replaceAll(key, "");
+    }
+    return stripped.trim() || text;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function feishuContentText(value) {
+    if (typeof value !== "string")
+        return "";
+    try {
+        const parsed = JSON.parse(value);
+        const record = asRecord(parsed);
+        if (typeof record?.text === "string")
+            return record.text;
+        if (typeof record?.content === "string")
+            return record.content;
+    }
+    catch {
+        return value;
+    }
+    return "";
+}
+function feishuMentions(message) {
+    const mentions = [];
+    const rawMentions = message.mentions;
+    if (Array.isArray(rawMentions)) {
+        for (const item of rawMentions) {
+            const mention = feishuMentionFromRecord(asRecord(item));
+            if (mention)
+                mentions.push(mention);
+        }
+    }
+    const contentMentions = feishuMentionsFromContent(message.content);
+    for (const mention of contentMentions) {
+        if (!mentions.some((item) => mentionKey(item) === mentionKey(mention)))
+            mentions.push(mention);
+    }
+    return mentions;
+}
+function feishuMentionFromRecord(record) {
+    if (!record)
+        return undefined;
+    const id = asRecord(record.id) ?? asRecord(record.user_id) ?? asRecord(record.userId);
+    const mention = {
+        ...(stringField(record, "key") ? { key: stringField(record, "key") } : {}),
+        ...(stringField(id, "open_id") ?? stringField(record, "open_id") ? { openId: stringField(id, "open_id") ?? stringField(record, "open_id") } : {}),
+        ...(stringField(id, "user_id") ?? stringField(record, "user_id") ? { userId: stringField(id, "user_id") ?? stringField(record, "user_id") } : {}),
+        ...(stringField(id, "union_id") ?? stringField(record, "union_id") ? { unionId: stringField(id, "union_id") ?? stringField(record, "union_id") } : {}),
+        ...(stringField(id, "app_id") ?? stringField(record, "app_id") ? { appId: stringField(id, "app_id") ?? stringField(record, "app_id") } : {}),
+        ...(stringField(record, "name") ? { name: stringField(record, "name") } : {}),
+        ...(record.is_bot === true || record.isBot === true ? { isBot: true } : {}),
+    };
+    return mention.openId || mention.userId || mention.unionId || mention.appId || mention.key || mention.name ? mention : undefined;
+}
+function feishuMentionsFromContent(value) {
+    if (typeof value !== "string")
+        return [];
+    const mentions = [];
+    try {
+        collectMentionsFromJson(JSON.parse(value), mentions);
+    }
+    catch {
+        collectMentionIdsFromText(value, mentions);
+    }
+    collectMentionIdsFromText(value, mentions);
+    return mentions;
+}
+function collectMentionsFromJson(value, output) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectMentionsFromJson(item, output);
+        return;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return;
+    const mention = feishuMentionFromRecord(record);
+    if (mention && !output.some((item) => mentionKey(item) === mentionKey(mention)))
+        output.push(mention);
+    for (const item of Object.values(record))
+        collectMentionsFromJson(item, output);
+}
+function collectMentionIdsFromText(value, output) {
+    for (const match of value.matchAll(/open_id=["']([^"']+)["']/giu)) {
+        const mention = { openId: match[1] };
+        if (!output.some((item) => mentionKey(item) === mentionKey(mention)))
+            output.push(mention);
+    }
+    for (const match of value.matchAll(/user_id=["']([^"']+)["']/giu)) {
+        const mention = { userId: match[1] };
+        if (!output.some((item) => mentionKey(item) === mentionKey(mention)))
+            output.push(mention);
+    }
+    for (const match of value.matchAll(/app_id=["']([^"']+)["']/giu)) {
+        const mention = { appId: match[1] };
+        if (!output.some((item) => mentionKey(item) === mentionKey(mention)))
+            output.push(mention);
+    }
+}
+function mentionKey(mention) {
+    return mention.openId ?? mention.userId ?? mention.unionId ?? mention.appId ?? mention.key ?? mention.name ?? "";
+}
+function isFeishuDirectChat(chatType) {
+    return chatType === "p2p" || chatType === "dm" || chatType === "direct" || chatType === "private";
+}
+function normalizeBotIdentity(value) {
+    if (typeof value === "string")
+        return value.trim() ? { openId: value.trim() } : undefined;
+    if (!value)
+        return undefined;
+    const identity = {
+        ...(value.openId ? { openId: value.openId } : {}),
+        ...(value.unionId ? { unionId: value.unionId } : {}),
+        ...(value.userId ? { userId: value.userId } : {}),
+        ...(value.appId ? { appId: value.appId } : {}),
+    };
+    return Object.keys(identity).length > 0 ? identity : undefined;
+}
+async function resolveFeishuBotIdentity(client) {
+    if (!client.request)
+        return undefined;
+    const response = await client.request({
+        url: "/open-apis/bot/v3/info",
+        method: "GET",
+    });
+    const record = asRecord(response);
+    const bot = asRecord(record?.bot) ?? asRecord(asRecord(record?.data)?.bot);
+    return normalizeBotIdentity({
+        ...(stringField(bot, "open_id") ?? stringField(record, "open_id") ? { openId: stringField(bot, "open_id") ?? stringField(record, "open_id") } : {}),
+        ...(stringField(bot, "union_id") ?? stringField(record, "union_id") ? { unionId: stringField(bot, "union_id") ?? stringField(record, "union_id") } : {}),
+        ...(stringField(bot, "user_id") ?? stringField(record, "user_id") ? { userId: stringField(bot, "user_id") ?? stringField(record, "user_id") } : {}),
+        ...(stringField(bot, "app_id") ?? stringField(record, "app_id") ? { appId: stringField(bot, "app_id") ?? stringField(record, "app_id") } : {}),
+    });
+}
+function platformMessageId(value) {
+    const record = asRecord(value);
+    const data = asRecord(record?.data);
+    return stringField(data, "message_id") ?? stringField(record, "message_id");
+}
+function platformReactionId(value) {
+    const record = asRecord(value);
+    const data = asRecord(record?.data);
+    return stringField(data, "reaction_id") ?? stringField(record, "reaction_id");
+}
+function reactionApi(client) {
+    return client.im?.v1?.messageReaction ?? client.im?.v1?.message_reaction;
+}
+function oldestPendingMessageId(pending) {
+    let oldestId;
+    let oldestTime = Number.POSITIVE_INFINITY;
+    for (const [messageId, value] of pending) {
+        if (value.createdAt < oldestTime) {
+            oldestId = messageId;
+            oldestTime = value.createdAt;
+        }
+    }
+    return oldestId;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+//# sourceMappingURL=feishu.js.map

package/apps/daemon/dist/gateway/format.d.ts

@@ -0,0 +1,2 @@
+import type { GatewayEventPayload } from "../../../../packages/shared/dist/index.js";
+export declare function formatGatewayPayload(payload: GatewayEventPayload): string;

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

@@ -0,0 +1,19 @@
+export function formatGatewayPayload(payload) {
+    if (payload.type === "notice") {
+        return [`[${payload.severity ?? "info"}] ${payload.title}`, payload.text].filter(Boolean).join("\n\n");
+    }
+    const lines = [
+        `Happy Elves turn ${payload.status}`,
+        payload.sessionName ? `Session: ${payload.sessionName}` : `Session: ${payload.sessionId}`,
+        `Turn: ${payload.turnId}`,
+    ];
+    const reason = payload.error ?? payload.stopReason;
+    if (reason)
+        lines.push(`Reason: ${reason}`);
+    if (payload.outputPreview?.trim()) {
+        lines.push("", "Output:", payload.outputPreview.trim());
+    }
+    lines.push("", "Reply in this chat/thread to continue the same Happy Elves session.");
+    return lines.join("\n");
+}
+//# sourceMappingURL=format.js.map

package/apps/daemon/dist/gateway/handler.d.ts

@@ -0,0 +1,7 @@
+import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+type GatewayCommand = Extract<MachineCommand, {
+    type: "machine:gateway";
+}>;
+export declare function handleGatewayCommand(ws: WebSocket, config: DaemonConfig, command: GatewayCommand): Promise<void>;
+export {};

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

@@ -0,0 +1,151 @@
+import { decryptJson } from "../../../../packages/shared/dist/index.js";
+import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
+import { deliverGatewayMessage, notifyGatewayConversation, publicChannelsForStore, setGatewayLastError, syncGatewayRuntime } from "./runtime.js";
+import { readGatewayStore, updateGatewayStore, upsertGatewayChannel } from "./store.js";
+export async function handleGatewayCommand(ws, config, command) {
+    if (!claimCommandRequest(ws, command.requestId))
+        return;
+    const result = await executeGatewayCommand(config, command);
+    await sendCommandResponse(ws, {
+        type: "machine:gatewayResult",
+        requestId: command.requestId,
+        machineId: config.machineId,
+        result,
+    });
+}
+async function executeGatewayCommand(config, command) {
+    if (command.action === "list") {
+        const store = await readGatewayStore();
+        return { action: "list", channels: publicChannelsForStore(store) };
+    }
+    if (command.action === "get") {
+        const store = await readGatewayStore();
+        const channel = requireChannel(store, command.channelId);
+        return { action: "get", channel: publicChannelsForStore(store).find((item) => item.id === channel.id) };
+    }
+    if (command.action === "upsert") {
+        if (!command.channel)
+            throw new Error("gateway upsert requires channel");
+        assertLocalTarget(config.machineId, command.channel.targetMachineId);
+        const input = await decryptGatewayChannelInput(config, command.channel);
+        const store = await updateGatewayStore((current) => upsertGatewayChannel(current, input, config.machineId));
+        const channel = requireChannel(store, command.channel.id ?? command.channel.type);
+        assertUsableChannel(channel);
+        await syncGatewayRuntime(config);
+        const nextStore = await readGatewayStore();
+        return { action: "upsert", channel: publicChannelsForStore(nextStore).find((item) => item.id === channel.id) };
+    }
+    if (command.action === "enable") {
+        const store = await updateGatewayStore((current) => ({
+            ...current,
+            channels: current.channels.map((channel) => channel.id === command.channelId
+                ? { ...channel, enabled: true, updatedAt: new Date().toISOString() }
+                : channel),
+        }));
+        const channel = requireChannel(store, command.channelId);
+        assertUsableChannel(channel);
+        await syncGatewayRuntime(config);
+        const nextStore = await readGatewayStore();
+        return { action: "enable", channel: publicChannelsForStore(nextStore).find((item) => item.id === channel.id) };
+    }
+    if (command.action === "disable") {
+        const store = await updateGatewayStore((current) => ({
+            ...current,
+            channels: current.channels.map((channel) => channel.id === command.channelId
+                ? { ...channel, enabled: false, updatedAt: new Date().toISOString() }
+                : channel),
+        }));
+        const channel = requireChannel(store, command.channelId);
+        await syncGatewayRuntime(config);
+        const nextStore = await readGatewayStore();
+        return { action: "disable", channel: publicChannelsForStore(nextStore).find((item) => item.id === channel.id) };
+    }
+    if (command.action === "test") {
+        const store = await readGatewayStore();
+        const channel = requireChannel(store, command.channelId);
+        if (!channel.enabled)
+            throw new Error("Gateway channel is disabled");
+        if (!command.externalConversationId || !command.externalMessageId || !command.text) {
+            throw new Error("gateway test requires externalConversationId, externalMessageId, and text");
+        }
+        try {
+            const delivery = await deliverGatewayMessage(config, channel, {
+                externalConversationId: command.externalConversationId,
+                externalMessageId: command.externalMessageId,
+                text: command.text,
+            });
+            const nextStore = await readGatewayStore();
+            return {
+                action: "test",
+                channel: publicChannelsForStore(nextStore).find((item) => item.id === channel.id),
+                delivery,
+            };
+        }
+        catch (error) {
+            await setGatewayLastError(channel.id, error);
+            throw error;
+        }
+    }
+    if (command.action === "notify") {
+        const store = await readGatewayStore();
+        const channel = requireChannel(store, command.channelId);
+        if (!channel.enabled)
+            throw new Error("Gateway channel is disabled");
+        if (!command.externalConversationId || !command.externalMessageId || !command.text) {
+            throw new Error("gateway notify requires externalConversationId, externalMessageId, and text");
+        }
+        try {
+            const delivery = await notifyGatewayConversation(channel, {
+                externalConversationId: command.externalConversationId,
+                externalMessageId: command.externalMessageId,
+                text: command.text,
+            });
+            const nextStore = await readGatewayStore();
+            return {
+                action: "notify",
+                channel: publicChannelsForStore(nextStore).find((item) => item.id === channel.id),
+                delivery,
+            };
+        }
+        catch (error) {
+            await setGatewayLastError(channel.id, error);
+            throw error;
+        }
+    }
+    throw new Error(`Unsupported gateway action: ${command.action}`);
+}
+async function decryptGatewayChannelInput(config, input) {
+    if (!input.encryptedAppSecret)
+        return input;
+    const secret = await decryptJson(config.accountSecret, input.encryptedAppSecret);
+    if (typeof secret.appSecret !== "string" || secret.appSecret.length === 0) {
+        throw new Error("Lark gateway encrypted appSecret is invalid");
+    }
+    return {
+        ...input,
+        appSecret: secret.appSecret,
+        encryptedAppSecret: undefined,
+    };
+}
+function requireChannel(store, channelId) {
+    if (!channelId)
+        throw new Error("gateway channelId is required");
+    const channel = store.channels.find((item) => item.id === channelId);
+    if (!channel)
+        throw new Error("Gateway channel not found");
+    return channel;
+}
+function assertLocalTarget(machineId, targetMachineId) {
+    if (targetMachineId && targetMachineId !== machineId) {
+        throw new Error("Gateway targetMachineId must match the daemon handling the command");
+    }
+}
+function assertUsableChannel(channel) {
+    if (channel.type === "lark" && (!channel.appId || !channel.appSecret)) {
+        throw new Error("Lark gateway requires appId and appSecret");
+    }
+    if (!channel.targetSessionId && !channel.targetCwd) {
+        throw new Error("Gateway needs target cwd or target session");
+    }
+}
+//# sourceMappingURL=handler.js.map