twinny 0.0.0-dev.260525150705

package/dist/app/wiring.js

@@ -0,0 +1,694 @@
+import path from "node:path";
+import { createRuntimePaths, loadTwinnyConfig, resolveBundledBannerPath, resolveBundledLogoPath, resolveLarkAppSecret, SecurityCliSecretStore } from "../config/index.js";
+import { ProfileCodexAppServerPool } from "../codex/index.js";
+import { ConversationManager } from "../conversation/manager.js";
+import { LarkEventConsumer, LarkFileDownloader, LarkMessageReader, LarkMessageSender, LarkBotDirectory, LarkChatDirectory, LarkUserDirectory, LarkOpenApiClient, resolveLarkEndpoints, resolveLarkEventDomain, TenantAccessTokenManager } from "../lark/index.js";
+import { acquireTwinnyLock } from "../lock/index.js";
+import { createLarkSdkLogger, createLogger, logger as defaultLogger } from "../observability/logs.js";
+import { TwinnySystemNotifier } from "../observability/system-notifications.js";
+import { getProfileCodexHome } from "../profiles/index.js";
+import { createConversationRepository, openRuntimeDatabase } from "../store/index.js";
+import { createTwinnyTelemetryClient, memoryUsageTelemetryProperties } from "../telemetry/index.js";
+import { WorkspaceManager } from "../workspace/index.js";
+import { MacIdleSleepPreventer } from "./caffeinate.js";
+import { provisionLarkAssetImageKeys as provisionRuntimeLarkAssetImageKeys } from "./lark-assets.js";
+export class TwinnyRuntime {
+    config;
+    options;
+    log;
+    larkSdkLogger;
+    paths;
+    secretStore = new SecurityCliSecretStore();
+    lock;
+    db;
+    codexPool;
+    idleSleepPreventer;
+    larkConsumer;
+    conversation;
+    systemNotifier;
+    codexRecoveryByProfile = new Map();
+    codexIntentionalStopByProfile = new Set();
+    telemetry;
+    heartbeatTimer;
+    runtimeStartedAt = 0;
+    stopped = false;
+    stopPromise;
+    resolveStopped;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.options = options;
+        this.log = options.logger ?? defaultLogger;
+        this.paths = createRuntimePaths(config.home);
+        this.larkSdkLogger =
+            options.larkSdkLogger ??
+                createLarkSdkLogger(createLogger({ logFile: path.join(this.paths.logsDir, "lark-sdk.log") }));
+        this.telemetry =
+            options.telemetry ??
+                createTwinnyTelemetryClient(config, {
+                    logger: this.log,
+                    codexVersion: () => this.readRuntimeCodexVersion()
+                });
+        this.stopPromise = new Promise((resolve) => {
+            this.resolveStopped = resolve;
+        });
+    }
+    async start() {
+        const launchStartedAt = Date.now();
+        this.runtimeStartedAt = launchStartedAt;
+        let lockAcquired = false;
+        let dbOpened = false;
+        let recoveryAttempted = false;
+        let larkConsumerStarted = false;
+        try {
+            this.lock = await acquireTwinnyLock(this.paths, { stale: 30_000, update: 10_000 });
+            lockAcquired = true;
+            this.idleSleepPreventer = this.options.idleSleepPreventer ?? new MacIdleSleepPreventer({ logger: this.log });
+            this.idleSleepPreventer.start();
+            this.db = openRuntimeDatabase(this.paths);
+            dbOpened = true;
+            const appSecretAccount = this.config.homeIdentity.keychainAccounts.larkAppSecret;
+            const appSecret = await resolveLarkAppSecret(appSecretAccount, this.secretStore);
+            if (!appSecret) {
+                throw new Error(`Lark app secret is missing: keychain:${appSecretAccount}`);
+            }
+            this.codexPool = new ProfileCodexAppServerPool({
+                binary: this.config.codex.binary,
+                profiles: this.config.profiles,
+                requestTimeoutMs: this.options.requestTimeoutMs ?? 10 * 60 * 1000
+            });
+            for (const profile of Object.keys(this.config.profiles)) {
+                this.attachCodexAppServerListeners(profile, this.codexPool.get(profile));
+            }
+            await this.codexPool.startAll();
+            const tokenManager = new TenantAccessTokenManager({
+                appId: this.config.auth.larkAppId,
+                appSecret,
+                baseUrl: resolveLarkEndpoints(this.config.auth.larkBrand).openApi
+            });
+            const openApiClient = new LarkOpenApiClient({
+                tokenManager,
+                baseUrl: resolveLarkEndpoints(this.config.auth.larkBrand).openApi
+            });
+            const larkSender = new LarkMessageSender({
+                openApiClient,
+                logger: this.log,
+                redaction: this.config.lark.messageRedaction
+            });
+            const larkMessages = new LarkMessageReader({ openApiClient });
+            const larkUsers = new LarkUserDirectory({ openApiClient });
+            const larkChats = new LarkChatDirectory({ openApiClient });
+            const larkBot = new LarkBotDirectory({ openApiClient });
+            const botOpenId = await larkBot.getBotOpenId().catch((error) => {
+                this.log.warn({ error }, "failed to resolve lark bot open_id; group @mention matching will be unavailable");
+                return undefined;
+            });
+            const larkFiles = new LarkFileDownloader({ openApiClient });
+            const assetImageKeys = await this.provisionLarkAssetImageKeys(larkFiles);
+            const systemNotifier = new TwinnySystemNotifier({
+                ownerOpenId: this.config.owner.openId,
+                sender: larkSender,
+                logger: this.log
+            });
+            this.systemNotifier = systemNotifier;
+            const repository = createConversationRepository(this.db);
+            const workspaceManager = WorkspaceManager.fromRuntimePaths(this.paths);
+            const conversation = new ConversationManager({
+                config: this.config,
+                repository: adaptConversationRepository(repository),
+                workspaces: workspaceManager,
+                codex: adaptCodexPool(this.codexPool),
+                lark: adaptLarkSender(larkSender, this.config.lark.workingReaction, this.config.lark.completedReaction, this.config.lark.queuedReaction),
+                larkUsers,
+                larkChats,
+                larkFiles,
+                larkMessages,
+                botOpenId,
+                assetImageKeys,
+                profiles: { codexHomeFor: (profile) => getProfileCodexHome(this.config, profile) },
+                runtime: { reloadProfile: (profile) => this.reloadProfile(profile) },
+                telemetry: this.telemetry,
+                logger: this.log
+            });
+            this.conversation = conversation;
+            recoveryAttempted = true;
+            await conversation.recoverUnfinishedMessages();
+            this.larkConsumer = new LarkEventConsumer({
+                appId: this.config.auth.larkAppId,
+                appSecret,
+                tokenManager,
+                domain: resolveLarkEventDomain(this.config.auth.larkBrand),
+                botOpenId,
+                logger: this.log,
+                sdkLogger: this.larkSdkLogger,
+                maxMessageAgeMs: this.config.lark.maxMessageAgeSeconds * 1000,
+                onMessage: (message) => {
+                    conversation.submitIncoming(message);
+                },
+                onMessageRecall: (recall) => {
+                    conversation.submitMessageRecall(recall);
+                },
+                onBotMenu: (action) => {
+                    conversation.submitBotMenuAction(action);
+                },
+                onCardAction: (action) => {
+                    conversation.submitCardAction(action);
+                },
+                onConnectionError: (error) => {
+                    this.telemetry.captureError(error, {
+                        errorType: "lark_event",
+                        errorSite: "lark.eventConsumer.connection",
+                        operation: "connection_error",
+                        fatal: false
+                    });
+                },
+                onIgnored: (reason) => this.log.debug({ reason }, "lark event ignored")
+            });
+            await this.larkConsumer.start();
+            larkConsumerStarted = true;
+            await this.systemNotifier.notifyInitialized({ bannerImageKey: assetImageKeys.bannerImageKey });
+            this.telemetry.capture("twinny_launch", {
+                launch_duration_ms: Date.now() - launchStartedAt,
+                codex_profile_count: this.codexPool.listProfiles().length,
+                lark_consumer_started: larkConsumerStarted,
+                lark_ready: this.larkConsumer.isReady,
+                has_bot_open_id: botOpenId !== undefined,
+                db_opened: dbOpened,
+                lock_acquired: lockAcquired,
+                recovery_attempted: recoveryAttempted,
+                ...memoryUsageTelemetryProperties()
+            }, {
+                insertId: `twinny_launch:${this.telemetry.runtimeId}`,
+                codexVersion: this.readRuntimeCodexVersion()
+            });
+            this.startHeartbeat();
+            this.log.info({ home: this.config.home }, "twinny daemon started");
+        }
+        catch (error) {
+            this.telemetry.captureError(error, {
+                errorType: "runtime_start",
+                errorSite: "runtime.start",
+                operation: "start",
+                fatal: true,
+                properties: {
+                    launch_duration_ms: Date.now() - launchStartedAt,
+                    lark_consumer_started: larkConsumerStarted,
+                    db_opened: dbOpened,
+                    lock_acquired: lockAcquired,
+                    recovery_attempted: recoveryAttempted
+                }
+            });
+            await this.cleanupAfterStartFailure(error);
+            throw error;
+        }
+    }
+    async cleanupAfterStartFailure(error) {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.log.error({ error }, "twinny daemon failed to start; cleaning up");
+        try {
+            await this.shutdownConversation();
+            await this.stopLarkConsumer();
+            await this.stopCodexPool("SIGTERM");
+            this.closeDatabase();
+        }
+        finally {
+            await this.releaseLock();
+            await this.stopIdleSleepPreventer();
+            await this.shutdownTelemetry();
+            this.resolveStopped();
+        }
+    }
+    async stop(signal = "SIGTERM") {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.log.info({ signal }, "stopping twinny daemon");
+        try {
+            this.stopHeartbeat();
+            await this.shutdownConversation();
+            await this.stopLarkConsumer();
+            await this.stopCodexPool(signal);
+            this.closeDatabase();
+        }
+        finally {
+            await this.releaseLock();
+            await this.stopIdleSleepPreventer(signal);
+            await this.shutdownTelemetry();
+            this.resolveStopped();
+        }
+    }
+    async wait() {
+        await this.stopPromise;
+    }
+    async handleCodexAppServerExit(profile) {
+        if (this.stopped) {
+            return;
+        }
+        const existing = this.codexRecoveryByProfile.get(profile);
+        if (existing) {
+            return existing;
+        }
+        const recovery = this.recoverCodexAppServer(profile).finally(() => {
+            if (this.codexRecoveryByProfile.get(profile) === recovery) {
+                this.codexRecoveryByProfile.delete(profile);
+            }
+        });
+        this.codexRecoveryByProfile.set(profile, recovery);
+        await recovery;
+    }
+    async recoverCodexAppServer(profile) {
+        const pool = this.codexPool;
+        if (!pool || this.stopped) {
+            return;
+        }
+        const suspended = (await this.conversation?.suspendActiveTurnsForCodexAppServerExit(profile)) ?? 0;
+        this.log.warn({ profile, suspended }, "recovering codex app-server after exit");
+        try {
+            await pool.restart(profile);
+            if (this.stopped) {
+                return;
+            }
+            const recovered = (await this.conversation?.recoverSuspendedActiveTurnsForCodexAppServerExit(profile)) ?? 0;
+            this.log.info({ profile, suspended, recovered }, "codex app-server recovered after exit");
+        }
+        catch (error) {
+            this.telemetry.captureError(error, {
+                errorType: "codex_app_server",
+                errorSite: "runtime.recoverCodexAppServer",
+                operation: "recover_codex_app_server",
+                fatal: false,
+                properties: { profile, suspended }
+            });
+            throw error;
+        }
+    }
+    attachCodexAppServerListeners(profile, server) {
+        server.on("stderr", (chunk) => {
+            this.log.debug({ profile, stream: "stderr", chunk }, "codex app-server stderr");
+        });
+        server.on("threadNameUpdated", (update) => {
+            this.conversation?.submitCodexThreadNameUpdated(update);
+        });
+        server.on("exit", (code, signal) => {
+            if (this.codexIntentionalStopByProfile.delete(profile)) {
+                this.log.info({ profile, code, signal }, "codex app-server stopped intentionally");
+                return;
+            }
+            this.log.error({ profile, code, signal }, "codex app-server exited");
+            this.telemetry.captureError(new Error("Codex app-server exited"), {
+                errorType: "codex_app_server",
+                errorSite: "runtime.codexAppServer.exit",
+                operation: "codex_app_server_exit",
+                fatal: false,
+                properties: { profile, code, signal }
+            });
+            void this.handleCodexAppServerExit(profile).catch((error) => {
+                this.log.error({ error, profile }, "failed to recover codex app-server after exit");
+            });
+        });
+    }
+    async reloadProfile(profile) {
+        const pool = this.codexPool;
+        if (!pool) {
+            throw new Error("Codex app-server pool is not started");
+        }
+        if (profile === "none") {
+            throw new Error("profile none is reserved");
+        }
+        const nextConfig = await loadTwinnyConfig({ home: this.config.home });
+        if (profile && !nextConfig.profiles[profile]) {
+            throw new Error(`Unknown profile: ${profile}`);
+        }
+        const currentProfiles = new Set(pool.listProfiles());
+        const nextProfiles = new Set(Object.keys(nextConfig.profiles));
+        const profilesToReload = profile
+            ? [profile]
+            : Array.from(new Set([...currentProfiles, ...nextProfiles]));
+        this.log.info({ profiles: profilesToReload }, "reloading twinny profiles");
+        for (const profileName of profilesToReload) {
+            const nextProfile = nextConfig.profiles[profileName];
+            if (!nextProfile) {
+                if (currentProfiles.has(profileName)) {
+                    await this.stopCodexAppServerForReload(pool, profileName);
+                }
+                continue;
+            }
+            const suspended = currentProfiles.has(profileName)
+                ? (await this.conversation?.suspendActiveTurnsForCodexAppServerExit(profileName)) ?? 0
+                : 0;
+            if (currentProfiles.has(profileName)) {
+                await this.stopCodexAppServerForReload(pool, profileName);
+            }
+            const server = pool.replace(profileName, {
+                binary: nextConfig.codex.binary,
+                codexHome: nextProfile.codexHome
+            });
+            this.attachCodexAppServerListeners(profileName, server);
+            await server.start();
+            const recovered = currentProfiles.has(profileName)
+                ? (await this.conversation?.recoverSuspendedActiveTurnsForCodexAppServerExit(profileName)) ?? 0
+                : 0;
+            this.log.info({ profile: profileName, suspended, recovered }, "reloaded codex app-server profile");
+        }
+        replaceTwinnyConfigContents(this.config, nextConfig);
+    }
+    async stopCodexAppServerForReload(pool, profile) {
+        this.codexIntentionalStopByProfile.add(profile);
+        try {
+            await pool.remove(profile);
+        }
+        finally {
+            this.codexIntentionalStopByProfile.delete(profile);
+        }
+    }
+    async shutdownConversation() {
+        if (!this.conversation) {
+            return;
+        }
+        const conversation = this.conversation;
+        this.conversation = undefined;
+        try {
+            await conversation.shutdown();
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to shutdown conversation manager cleanly");
+        }
+    }
+    async stopLarkConsumer() {
+        if (!this.larkConsumer) {
+            return;
+        }
+        const consumer = this.larkConsumer;
+        this.larkConsumer = undefined;
+        try {
+            await consumer.stop({ force: true });
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to stop lark event consumer cleanly");
+        }
+    }
+    async stopCodexPool(signal) {
+        if (!this.codexPool) {
+            return;
+        }
+        const pool = this.codexPool;
+        this.codexPool = undefined;
+        try {
+            await pool.stopAll(signal);
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to stop codex app-server pool cleanly");
+        }
+    }
+    closeDatabase() {
+        if (!this.db) {
+            return;
+        }
+        const db = this.db;
+        this.db = undefined;
+        try {
+            db.close();
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to close sqlite database cleanly");
+        }
+    }
+    async releaseLock() {
+        if (!this.lock) {
+            return;
+        }
+        const lock = this.lock;
+        this.lock = undefined;
+        try {
+            await lock.release();
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to release runtime lock cleanly");
+        }
+    }
+    async stopIdleSleepPreventer(signal = "SIGTERM") {
+        if (!this.idleSleepPreventer) {
+            return;
+        }
+        const preventer = this.idleSleepPreventer;
+        this.idleSleepPreventer = undefined;
+        try {
+            await preventer.stop(signal);
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to stop caffeinate idle sleep assertion cleanly");
+        }
+    }
+    async provisionLarkAssetImageKeys(larkFiles) {
+        return provisionRuntimeLarkAssetImageKeys({
+            cacheFile: this.paths.larkAssetsFile,
+            logoFilePath: this.options.logoFilePath ?? resolveBundledLogoPath(),
+            bannerFilePath: this.options.bannerFilePath ?? resolveBundledBannerPath(),
+            uploader: larkFiles,
+            logger: this.log
+        });
+    }
+    startHeartbeat() {
+        if (this.options.disableHeartbeat) {
+            return;
+        }
+        const intervalMs = this.options.heartbeatIntervalMs ?? 60 * 60 * 1000;
+        this.heartbeatTimer = setInterval(() => this.captureHeartbeat(intervalMs), intervalMs);
+        this.heartbeatTimer.unref?.();
+    }
+    stopHeartbeat() {
+        if (!this.heartbeatTimer) {
+            return;
+        }
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = undefined;
+    }
+    captureHeartbeat(intervalMs) {
+        const stats = this.conversation?.getRuntimeStats() ?? {
+            activeTurnCount: 0,
+            sideTurnCount: 0,
+            queuedMessageCount: 0,
+            suspendedTurnCount: 0
+        };
+        this.telemetry.capture("twinny_heartbeat", {
+            uptime_ms: Date.now() - this.runtimeStartedAt,
+            lark_consumer_running: this.larkConsumer?.isRunning ?? false,
+            lark_ready: this.larkConsumer?.isReady ?? false,
+            lark_connection_status: safeConnectionStatus(this.larkConsumer?.getConnectionStatus()),
+            codex_profile_count: this.codexPool?.listProfiles().length ?? 0,
+            active_turn_count: stats.activeTurnCount,
+            side_turn_count: stats.sideTurnCount,
+            queued_message_count: stats.queuedMessageCount,
+            suspended_turn_count: stats.suspendedTurnCount,
+            ...memoryUsageTelemetryProperties()
+        }, {
+            insertId: `twinny_heartbeat:${this.telemetry.runtimeId}:${Math.floor(Date.now() / intervalMs)}`,
+            codexVersion: this.readRuntimeCodexVersion()
+        });
+    }
+    readRuntimeCodexVersion() {
+        const profile = this.codexPool?.listProfiles()[0];
+        return profile ? this.codexPool?.get(profile).readCodexVersion() ?? null : null;
+    }
+    async shutdownTelemetry() {
+        try {
+            await this.telemetry.shutdown?.();
+        }
+        catch (error) {
+            this.log.warn({ error }, "failed to shutdown telemetry");
+        }
+    }
+}
+export async function createRuntime(config, options = {}) {
+    return new TwinnyRuntime(config, options);
+}
+function replaceTwinnyConfigContents(target, source) {
+    Object.assign(target, source);
+}
+function safeConnectionStatus(status) {
+    if (status === undefined || status === null) {
+        return null;
+    }
+    if (typeof status === "string" || typeof status === "number" || typeof status === "boolean") {
+        return String(status);
+    }
+    try {
+        return JSON.stringify(status).slice(0, 256);
+    }
+    catch {
+        return String(status).slice(0, 256);
+    }
+}
+export function adaptConversationRepository(repository) {
+    return {
+        findByConversationKey: (conversationKey) => repository.getByConversationKey(conversationKey) ?? null,
+        create: repository.create.bind(repository),
+        updateThreadBinding: repository.updateThreadBinding.bind(repository),
+        updateConversationSettings: repository.updateConversationSettings.bind(repository),
+        markThreadHasRollout: repository.markThreadHasRollout.bind(repository),
+        getCodexThreadById: repository.getCodexThreadById.bind(repository),
+        getCodexThreadByConversationAndLarkThread: repository.getCodexThreadByConversationAndLarkThread.bind(repository),
+        getLarkMessageById: repository.getLarkMessageById.bind(repository),
+        getLarkMessageByEventId: repository.getLarkMessageByEventId.bind(repository),
+        getLarkMessageUsageTargetForTurn: repository.getLarkMessageUsageTargetForTurn.bind(repository),
+        getLatestSteeredLarkMessageForTurn: repository.getLatestSteeredLarkMessageForTurn.bind(repository),
+        listUnfinishedLarkMessages: repository.listUnfinishedLarkMessages.bind(repository),
+        upsertCodexThread: repository.upsertCodexThread.bind(repository),
+        replaceCodexThreadForLarkThread: repository.replaceCodexThreadForLarkThread.bind(repository),
+        updateCodexThreadTokenUsage: repository.updateCodexThreadTokenUsage.bind(repository),
+        updateCodexThreadGoalStatus: repository.updateCodexThreadGoalStatus.bind(repository),
+        clearCodexThreadGoalStatus: repository.clearCodexThreadGoalStatus.bind(repository),
+        updateCodexThreadCard: repository.updateCodexThreadCard.bind(repository),
+        updateCodexThreadModelSettings: repository.updateCodexThreadModelSettings.bind(repository),
+        updateCodexThreadName: repository.updateCodexThreadName.bind(repository),
+        updateCodexThreadMode: repository.updateCodexThreadMode.bind(repository),
+        updateCodexThreadStatus: repository.updateCodexThreadStatus.bind(repository),
+        getCodexThreadWorkStats: repository.getCodexThreadWorkStats.bind(repository),
+        getCodexThreadStatusStats: repository.getCodexThreadStatusStats.bind(repository),
+        getConversationStatusStats: repository.getConversationStatusStats.bind(repository),
+        insertLarkMessage: repository.insertLarkMessage.bind(repository),
+        markLarkMessageQueued: repository.markLarkMessageQueued.bind(repository),
+        markLarkMessageRecalled: repository.markLarkMessageRecalled.bind(repository),
+        updateQueuedLarkMessage: repository.updateQueuedLarkMessage.bind(repository),
+        updateLarkMessageSideMetadata: repository.updateLarkMessageSideMetadata.bind(repository),
+        updateLarkMessageTokenUsage: repository.updateLarkMessageTokenUsage.bind(repository),
+        markLarkMessagesProcessing: repository.markLarkMessagesProcessing.bind(repository),
+        markLarkMessagesSteered: repository.markLarkMessagesSteered.bind(repository),
+        markLarkMessagesCompleted: repository.markLarkMessagesCompleted.bind(repository),
+        markLarkMessagesFailed: repository.markLarkMessagesFailed.bind(repository),
+        markLarkMessagesInterrupted: repository.markLarkMessagesInterrupted.bind(repository),
+        markLarkMessagesCleared: repository.markLarkMessagesCleared.bind(repository)
+    };
+}
+function adaptCodexPool(pool) {
+    return {
+        startThread: async ({ profile, cwd, developerInstructions }) => {
+            const response = await pool.get(profile).startThread(cwd, { developerInstructions });
+            return { threadId: response.thread.id };
+        },
+        resumeThread: async ({ profile, threadId, cwd }) => {
+            const response = await pool.get(profile).resumeThread(threadId, cwd);
+            return { threadId: response.thread.id };
+        },
+        forkThread: async ({ profile, threadId, cwd, ephemeral, developerInstructions, model, effort }) => {
+            const response = await pool.get(profile).forkThread(threadId, cwd, {
+                ephemeral,
+                developerInstructions,
+                model,
+                effort
+            });
+            return { threadId: response.thread.id };
+        },
+        injectThreadItems: async ({ profile, threadId, items }) => {
+            await pool.get(profile).injectThreadItems(threadId, items);
+        },
+        unsubscribeThread: async ({ profile, threadId }) => {
+            await pool.get(profile).unsubscribeThread(threadId);
+        },
+        startTurn: async ({ profile, threadId, input, currentThreadName, cwd, mode, model, effort, onTurnStarted, onAgentMessage, onImageGeneration, onTokenUsage, onPlanUpdated, onRequestUserInput, onSetThreadName }) => pool.get(profile).startTurn({
+            threadId,
+            ...(typeof input === "string" ? { text: input } : { input }),
+            currentThreadName,
+            cwd,
+            mode,
+            model,
+            effort,
+            onTurnStarted,
+            onAgentMessage,
+            onImageGeneration,
+            onTokenUsage,
+            onPlanUpdated,
+            onRequestUserInput,
+            onSetThreadName
+        }),
+        compactThread: async ({ profile, threadId, cwd, onTurnStarted, onTokenUsage }) => pool.get(profile).compactThread({
+            threadId,
+            cwd,
+            onTurnStarted,
+            onTokenUsage
+        }),
+        setThreadGoal: async ({ profile, threadId, objective }) => pool.get(profile).setThreadGoal(threadId, objective),
+        getThreadGoal: async ({ profile, threadId }) => pool.get(profile).getThreadGoal(threadId),
+        clearThreadGoal: async ({ profile, threadId }) => {
+            await pool.get(profile).clearThreadGoal(threadId);
+        },
+        setThreadName: async ({ profile, threadId, name }) => {
+            await pool.get(profile).setThreadName(threadId, name);
+        },
+        runGoal: async ({ profile, ...options }) => pool.get(profile).runGoal(options),
+        resumeGoal: async ({ profile, ...options }) => pool.get(profile).resumeGoal(options),
+        steerTurn: async ({ profile, threadId, turnId, input }) => {
+            await pool.get(profile).steerTurn({
+                threadId,
+                turnId,
+                ...(typeof input === "string" ? { text: input } : { input })
+            });
+        },
+        interruptTurn: async ({ profile, threadId, turnId }) => {
+            await pool.get(profile).interruptTurn({ threadId, turnId });
+        },
+        readCodexVersion: ({ profile }) => {
+            return pool.get(profile).readCodexVersion();
+        },
+        readAccountRateLimits: async ({ profile }) => {
+            return pool.get(profile).readAccountRateLimits();
+        }
+    };
+}
+function adaptLarkSender(sender, workingReaction, completedReaction, queuedReaction) {
+    return {
+        addTypingReaction: (messageId) => sender.createReaction(messageId, workingReaction),
+        addCompletedReaction: (messageId) => sender.createReaction(messageId, completedReaction),
+        addQueuedReaction: (messageId) => sender.createReaction(messageId, queuedReaction),
+        removeReaction: (handle) => sender.deleteReaction(handle),
+        replyText: async (messageId, text, options) => {
+            return sender.replyText(messageId, text, options);
+        },
+        replyMarkdown: async (messageId, markdown, options) => {
+            return sender.replyMarkdown(messageId, markdown, options);
+        },
+        replyPost: async (messageId, content, options) => {
+            return sender.replyPost(messageId, content, options);
+        },
+        replyFile: async (messageId, fileKey) => {
+            return sender.replyFile(messageId, fileKey);
+        },
+        replyImage: async (messageId, imageKey) => {
+            return sender.replyImage(messageId, imageKey);
+        },
+        sendTextToOpenId: async (openId, text) => {
+            await sender.sendTextToOpenId(openId, text);
+        },
+        sendCardToOpenId: async (openId, card, options) => {
+            return sender.sendInteractiveCardToOpenId(openId, card, options);
+        },
+        sendCardToChatId: async (chatId, card, options) => {
+            return sender.sendInteractiveCardToChatId(chatId, card, options);
+        },
+        sendEphemeralCardToChatId: async (chatId, openId, card) => {
+            return sender.sendEphemeralInteractiveCardToChatId(chatId, openId, card);
+        },
+        forwardThreadToThread: async (threadId, receiveThreadId, options) => {
+            return sender.forwardThreadToThread(threadId, receiveThreadId, options);
+        },
+        replyCard: async (messageId, card, options) => {
+            return sender.replyInteractiveCard(messageId, card, options);
+        },
+        patchCard: async (messageId, card) => {
+            return sender.patchInteractiveCard(messageId, card);
+        },
+        recallMessage: async (messageId) => {
+            await sender.deleteMessage(messageId);
+        },
+        deleteEphemeralMessage: async (messageId) => {
+            await sender.deleteEphemeralMessage(messageId);
+        },
+        getMessageReadOpenIds: async (messageId) => {
+            return sender.listMessageReadOpenIds(messageId);
+        }
+    };
+}
+//# sourceMappingURL=wiring.js.map