@rynx-ai/plugin-channel-lark 0.1.9

package/dist/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { PluginRuntimeContext, PluginRuntimeHandle, PluginStartContributionRequest } from "@rynx-ai/plugin-sdk";
+import { type LarkBotRuntime } from "./lark.js";
+export declare const LARK_CHANNEL_ID = "lark";
+export interface LarkPluginRuntimeOptions {
+    createBot?: (input: {
+        context: PluginRuntimeContext;
+        request: Extract<PluginStartContributionRequest, {
+            kind: "chat-channel";
+        }>;
+        instanceDataDir: string;
+    }) => Promise<LarkBotRuntime> | LarkBotRuntime;
+}
+/** Runtime-module entry loaded only inside the isolated plugin runner process. */
+export declare function activate(context: PluginRuntimeContext): PluginRuntimeHandle;
+/** Exported separately so lifecycle behavior can be tested without opening Lark WebSocket. */
+export declare function createLarkPluginRuntime(context: PluginRuntimeContext, options?: LarkPluginRuntimeOptions): PluginRuntimeHandle;

package/dist/runtime.js

@@ -0,0 +1,157 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { HostAgentCatalog, HostAgentCapabilities, HostConversationRuntime, HostProvisionedLarkSessionStore, HostSessionProvisioner, } from "./host-adapters.js";
+import { FileLarkConversationDirectory } from "./lark-conversation-directory.js";
+import { LocalLarkBotRuntime } from "./lark.js";
+import { authorizeLark } from "./lark-setup.js";
+export const LARK_CHANNEL_ID = "lark";
+/** Runtime-module entry loaded only inside the isolated plugin runner process. */
+export function activate(context) {
+    return createLarkPluginRuntime(context);
+}
+/** Exported separately so lifecycle behavior can be tested without opening Lark WebSocket. */
+export function createLarkPluginRuntime(context, options = {}) {
+    const instances = new Map();
+    const createBot = options.createBot ?? createDefaultBot;
+    let disposed = false;
+    return {
+        async startContribution(request) {
+            assertLarkChatRequest(request);
+            if (disposed)
+                throw new Error("Lark plugin runtime is disposed");
+            if (instances.has(request.instanceId)) {
+                throw new Error(`Lark channel instance is already running: ${request.instanceId}`);
+            }
+            const instanceDataDir = path.join(context.dataDir, "instances", request.instanceId);
+            await mkdir(instanceDataDir, { recursive: true });
+            const entry = {
+                bot: await createBot({ context, request, instanceDataDir }),
+                status: { state: "starting", connected: false, lastError: null, lastEventAt: null },
+            };
+            instances.set(request.instanceId, entry);
+            try {
+                await entry.bot.start();
+                entry.status = botStatus(entry.bot, "running");
+            }
+            catch (error) {
+                entry.status = {
+                    ...botStatus(entry.bot, "failed"),
+                    lastError: error instanceof Error ? error.message : String(error),
+                };
+                throw error;
+            }
+        },
+        async stopContribution(target) {
+            assertLarkChatTarget(target);
+            const entry = instances.get(target.instanceId);
+            if (!entry)
+                return;
+            entry.status = { ...entry.status, state: "stopping" };
+            try {
+                await entry.bot.stop();
+                entry.status = botStatus(entry.bot, "stopped");
+            }
+            finally {
+                instances.delete(target.instanceId);
+            }
+        },
+        async status(target) {
+            assertLarkChatTarget(target);
+            const entry = instances.get(target.instanceId);
+            return entry ? botStatus(entry.bot, entry.status.state) : { state: "stopped", connected: false };
+        },
+        async authorize(request, emit, signal) {
+            assertLarkAuthorizeRequest(request);
+            const result = await authorizeLark(emit, signal);
+            return result;
+        },
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            const stopping = [...instances.values()].map((entry) => entry.bot.stop());
+            instances.clear();
+            const results = await Promise.allSettled(stopping);
+            const failure = results.find((result) => result.status === "rejected");
+            if (failure)
+                throw failure.reason;
+        },
+    };
+}
+async function createDefaultBot({ context, request, instanceDataDir, }) {
+    const conversationRuntime = new HostConversationRuntime(context.host);
+    const capabilities = new HostAgentCapabilities(context.host);
+    const agentCatalog = new HostAgentCatalog(context.host);
+    const provisioner = new HostSessionProvisioner(context.host, request.instanceId);
+    const activeSessionStore = new HostProvisionedLarkSessionStore({
+        filePath: path.join(instanceDataDir, "sessions.json"),
+        provisioner,
+        defaultAgent: request.defaultAgent ?? request.executionDefaults.defaultAgent,
+    });
+    const conversationDirectory = new FileLarkConversationDirectory({
+        filePath: path.join(instanceDataDir, "conversations.json"),
+    });
+    return new LocalLarkBotRuntime({
+        executionDefaults: request.executionDefaults,
+        agentCatalog,
+        conversationRuntime,
+        capabilities,
+        options: { ...request.config },
+        defaultAgent: request.defaultAgent,
+        activeSessionStore,
+        conversationDirectory,
+        sessionTitleWriter: (sessionId, title) => provisioner.setTitle(sessionId, title),
+        sessionProvisioner: async ({ sessionKey, fromSessionId }) => provisioner.provision(provisioner.forkOperationId(fromSessionId, sessionKey)),
+        logger: {
+            log(entry) {
+                context.logger.info("Lark channel event", jsonFields(entry));
+            },
+        },
+    });
+}
+function botStatus(bot, state) {
+    const value = bot.getStatus();
+    return {
+        state,
+        connected: value.connected,
+        lastError: value.last_error,
+        lastEventAt: value.last_event_at,
+    };
+}
+function assertLarkChatRequest(request) {
+    if (request.kind !== "chat-channel" || request.contributionId !== LARK_CHANNEL_ID) {
+        throw new Error("Lark runtime only implements the lark chat-channel contribution");
+    }
+}
+function assertLarkChatTarget(target) {
+    if (target.kind !== "chat-channel" || target.contributionId !== LARK_CHANNEL_ID) {
+        throw new Error("Lark runtime only implements the lark chat-channel contribution");
+    }
+}
+function assertLarkAuthorizeRequest(request) {
+    if (request.kind !== "chat-channel" || request.contributionId !== LARK_CHANNEL_ID) {
+        throw new Error("Lark runtime only authorizes the lark chat-channel contribution");
+    }
+}
+function jsonFields(value) {
+    const fields = {};
+    for (const [key, item] of Object.entries(value)) {
+        const normalized = jsonValue(item);
+        if (normalized !== undefined)
+            fields[key] = normalized;
+    }
+    return fields;
+}
+function jsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (Array.isArray(value)) {
+        return value.map((item) => jsonValue(item) ?? null);
+    }
+    if (typeof value === "object") {
+        return jsonFields(value);
+    }
+    return value === undefined ? undefined : String(value);
+}