@kafca/agentdock 0.1.57 → 0.1.58

package/dist-electron/services/local-ai-core/src/channel/weixin/local-core-weixin-gateway.js

@@ -16,6 +16,7 @@ const thread_routing_js_1 = require("../shared/thread-routing.js");
 const base_channel_gateway_js_1 = require("../shared/base-channel-gateway.js");
 const inbound_authorization_js_1 = require("../shared/inbound-authorization.js");
 const channel_keys_js_1 = require("../shared/channel-keys.js");
+const local_core_slash_commands_js_1 = require("../../acp/local-core-slash-commands.js");
 const config_js_1 = require("./config.js");
 const transport_js_1 = require("./transport.js");
 const runtime_state_js_1 = require("./runtime-state.js");
@@ -201,10 +202,7 @@ class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGatewa
             && event.type !== 'status') {
             return;
         }
-        const previous = this.outboundEventChains.get(sessionKey) || Promise.resolve();
-        const current = previous
-            .catch(() => undefined)
-            .then(async () => {
+        const current = this.scheduleOutboundChain(sessionKey, async () => {
             const binding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, routePlatformKey);
             if (!binding)
                 return;
@@ -246,19 +244,13 @@ class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGatewa
                 this.options.log?.(`localcore-weixin sent message for sessionKey=${sessionKey} type=${event.type} sent=${turn.sentCount}/${binding.last_platform_message_id ? WEIXIN_CONTEXT_SEND_LIMIT : 'unlimited'}`);
             }
             catch (error) {
-                this.options.log?.(`localcore-weixin send failed for sessionKey=${sessionKey}: ${(0, text_utils_js_1.formatWeixinError)(error)}`);
-            }
-        })
-            .finally(() => {
-            if (this.outboundEventChains.get(sessionKey) === current) {
-                this.outboundEventChains.delete(sessionKey);
+                this.options.log?.(`localcore-weixin send failed for sessionKey=${sessionKey}: ${(0, local_core_errors_js_1.formatSafeError)(error)}`);
             }
         });
-        this.outboundEventChains.set(sessionKey, current);
         await current;
     }
     registerScheduledThreadBridge(input) {
-        const instanceId = input.route.instanceId || getWeixinInstanceId(input.platform) || 'default';
+        const instanceId = input.route.instanceId || (0, channel_keys_js_1.extractChannelInstanceId)(input.platform, 'weixin') || 'default';
         const platformKey = (0, channel_keys_js_1.channelPlatformKey)('weixin', instanceId);
         const route = {
             workspaceId: input.workspaceId,
@@ -413,7 +405,7 @@ class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGatewa
             authorized,
         });
         const normalizedText = String(msg.text || '').trim().toLowerCase();
-        const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(msg.workspaceId, msg.chatId, msg.platformUserId, msg.platformKey) : '';
+        const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(msg.workspaceId, msg.chatId, msg.platformUserId, msg.platformKey || 'weixin') : '';
         if (permissionThreadId && permissionThreadId !== threadId) {
             threadId = permissionThreadId;
         }
@@ -427,7 +419,7 @@ class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGatewa
             threadId,
         });
         // Handle slash commands
-        const slashCommand = this.parseSlashCommand(msg.text);
+        const slashCommand = (0, local_core_slash_commands_js_1.parseSlashCommand)(msg.text);
         const sessionCommand = await this.executeSessionCommand({
             workspaceId: msg.workspaceId,
             currentThreadId: threadId,
@@ -453,13 +445,6 @@ class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGatewa
         await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(msg.text, msg.contentParts));
         return;
     }
-    async resolveDefaultAgentType(workspaceId, threadId) {
-        const router = this.options.getWorkspaceRouter();
-        if (typeof router.getWorkspaceDefaultAgentType === 'function') {
-            return router.getWorkspaceDefaultAgentType(workspaceId);
-        }
-        return this.options.store.getThreadRow(threadId)?.agent_type || 'codex';
-    }
     // ==================== Private: Bindings ====================
     // ==================== Private: Workspace Lifecycle ====================
     async startWorkspace(binding) {
@@ -723,28 +708,5 @@ class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGatewa
         this.processedInboundMessages.set(key, now + PROCESSED_MESSAGE_TTL_MS);
         return false;
     }
-    findAwaitingPermissionThreadId(workspaceId, chatId, platformUserId, platformKey = 'weixin') {
-        for (const [sessionKey, route] of this.threadRouting.entries()) {
-            if (route.workspaceId !== workspaceId || route.platformKey !== platformKey || route.chatId !== chatId || route.platformUserId !== platformUserId)
-                continue;
-            const turn = this.outboundTurns.get(sessionKey);
-            if (turn?.awaitingPermission && route.threadId)
-                return route.threadId;
-        }
-        return '';
-    }
-    parseSlashCommand(text) {
-        const normalized = String(text || '').trim();
-        if (!normalized.startsWith('/'))
-            return null;
-        const [name = '', ...args] = normalized.slice(1).split(/\s+/);
-        if (!name)
-            return null;
-        return { name: name.trim().toLowerCase(), args };
-    }
 }
 exports.LocalCoreWeixinGateway = LocalCoreWeixinGateway;
-function getWeixinInstanceId(platform) {
-    const normalized = String(platform || '').trim();
-    return normalized.startsWith('weixin:') ? normalized.slice('weixin:'.length).trim() : '';
-}

package/dist-electron/services/local-ai-core/src/channel/weixin/runtime-state.js

@@ -5,6 +5,7 @@ exports.getOrCreateWeixinTurnState = getOrCreateWeixinTurnState;
 exports.consumeWeixinBridgeEvent = consumeWeixinBridgeEvent;
 exports.renderWeixinTurnText = renderWeixinTurnText;
 exports.isTerminalWeixinBridgeMessage = isTerminalWeixinBridgeMessage;
+const bridge_event_helpers_js_1 = require("../shared/bridge-event-helpers.js");
 function renderBridgeContent(event) {
     const toolCall = event.toolCall;
     if (!toolCall) {
@@ -16,16 +17,8 @@ function renderBridgeContent(event) {
         return '';
     return [name, status].filter(Boolean).join(' - ');
 }
-function bridgeEventKind(event) {
-    return event.bridgeKind || (event.type === 'status' ? 'status' : 'assistant');
-}
 function pushUnique(target, value) {
-    const normalized = value.trim();
-    if (!normalized || target[target.length - 1] === normalized)
-        return;
-    target.push(normalized);
-    if (target.length > 8)
-        target.splice(0, target.length - 8);
+    (0, bridge_event_helpers_js_1.pushUniqueLine)(target, value, 8);
 }
 function flushPendingThought(turn) {
     const text = String(turn.pendingThoughtText || '').trim();
@@ -61,7 +54,7 @@ function getOrCreateWeixinTurnState(turns, sessionKey) {
 }
 function consumeWeixinBridgeEvent(turn, event) {
     const content = renderBridgeContent(event);
-    const bridgeKind = bridgeEventKind(event);
+    const bridgeKind = (0, bridge_event_helpers_js_1.resolveBridgeEventKind)(event);
     if (event.type === 'typing_start') {
         Object.assign(turn, {
             processing: true,
@@ -149,7 +142,7 @@ function isTerminalWeixinBridgeMessage(event, rendered) {
         return true;
     if (event.type !== 'reply')
         return false;
-    const kind = bridgeEventKind(event);
+    const kind = (0, bridge_event_helpers_js_1.resolveBridgeEventKind)(event);
     if (kind === 'tool' || kind === 'thought' || kind === 'plan' || kind === 'status')
         return false;
     return Boolean(rendered.trim());

package/dist-electron/services/local-ai-core/src/channel/weixin/text-utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripWeixinHtml = stripWeixinHtml;
-exports.formatWeixinError = formatWeixinError;
 exports.waitForWeixinRetry = waitForWeixinRetry;
 exports.utf8ByteLength = utf8ByteLength;
 exports.splitTextByUtf8Bytes = splitTextByUtf8Bytes;
@@ -21,13 +20,6 @@ function stripWeixinHtml(html) {
         .replace(/'/g, "'")
         .replace(/ /g, ' ');
 }
-function formatWeixinError(error) {
-    if (error instanceof Error) {
-        const cause = error.cause;
-        return cause !== undefined ? `${error.message}: ${String(cause)}` : error.message;
-    }
-    return String(error);
-}
 function waitForWeixinRetry(ms, signal) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(resolve, ms);

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -10,6 +10,7 @@ const job_id_js_1 = require("../scheduler/job-id.js");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
 const monitor_id_js_1 = require("../automation/monitor-id.js");
 const monitor_cli_parsers_js_1 = require("./monitor-cli-parsers.js");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
 const DEFAULT_BASE_URL = 'http://127.0.0.1:9831/api/local/v1';
 async function runCli(argv, env = node_process_1.default.env, io = node_process_1.default) {
     try {
@@ -69,7 +70,7 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
         }
     }
     catch (error) {
-        io.stderr.write(`${formatError(error)}\n`);
+        io.stderr.write(`${(0, local_core_errors_js_1.formatSafeError)(error)}\n`);
         return 1;
     }
 }
@@ -324,7 +325,7 @@ async function request(baseUrl, method, path, body) {
         });
     }
     catch (error) {
-        throw new Error(`Local AI Core is unavailable at ${baseUrl}: ${formatError(error)}`);
+        throw new Error(`Local AI Core is unavailable at ${baseUrl}: ${(0, local_core_errors_js_1.formatSafeError)(error)}`);
     }
     const payload = await response.json();
     if (!response.ok || !payload.ok) {
@@ -517,9 +518,6 @@ function monitorMatchesCliContext(monitor, context) {
         updatedAt: monitor.updatedAt,
     }, context);
 }
-function formatError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 void (async () => {
     if (require.main !== module) {
         return;

package/dist-electron/services/local-ai-core/src/kernel/local-core-errors.js

@@ -4,6 +4,7 @@ exports.LocalCoreErrorReporter = exports.LocalCoreError = void 0;
 exports.toLocalCoreErrorInfo = toLocalCoreErrorInfo;
 exports.formatUserError = formatUserError;
 exports.formatLogError = formatLogError;
+exports.formatSafeError = formatSafeError;
 exports.errorInfoToHttpBody = errorInfoToHttpBody;
 const DEFAULTS = {
     runtime_not_found: {
@@ -175,6 +176,13 @@ function formatLogError(info) {
     const message = typeof info.message === 'string' ? info.message : safeStringify(info.message);
     return `${info.code}: ${message}${suffix}`;
 }
+function formatSafeError(error) {
+    if (error instanceof Error) {
+        const cause = error.cause;
+        return cause !== undefined ? `${error.message}: ${cause instanceof Error ? cause.message : coerceErrorMessage(cause)}` : error.message;
+    }
+    return coerceErrorMessage(error);
+}
 function errorInfoToHttpBody(info) {
     return {
         ok: false,

package/dist-electron/services/local-ai-core/src/sandbox/opensandbox-client.js

@@ -82,8 +82,9 @@ class OpenSandboxClient {
             });
         }
         catch (error) {
-            throw new local_core_errors_js_1.LocalCoreError('sandbox_unavailable', `OpenSandbox request failed: ${error instanceof Error ? error.message : String(error)}`, {
-                cause: error instanceof Error ? error.message : String(error),
+            const message = (0, local_core_errors_js_1.formatSafeError)(error);
+            throw new local_core_errors_js_1.LocalCoreError('sandbox_unavailable', `OpenSandbox request failed: ${message}`, {
+                cause: message,
                 details: { method, path, serverUrl: this.options.serverUrl },
             });
         }

package/dist-electron/services/local-ai-core/src/scheduler/base-channel-schedule-adapter.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseChannelScheduleAdapter = void 0;
+const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
+const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
+const thread_resolution_js_1 = require("./thread-resolution.js");
+class BaseChannelScheduleAdapter {
+    options;
+    executor;
+    constructor(options) {
+        this.options = options;
+        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+        });
+    }
+    supports(job) {
+        return (0, scheduled_job_route_js_1.platformMatches)(job.platform, this.platformBase) && this.supportedRouteTypes.includes(job.route.type);
+    }
+    async execute(context) {
+        const { job } = context;
+        const executionPolicy = this.createPolicy(job, {
+            store: this.options.store,
+            workspaceRouter: this.options.getWorkspaceRouter(),
+            getChannelRuntime: this.options.getChannelRuntime,
+        }, (nextJob) => this.resolveThread(nextJob), (nextJob) => this.preferredAgentFor(nextJob));
+        const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
+        return {
+            threadId: execution.threadId,
+            runId: execution.runId,
+            replyText: execution.replyText,
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'succeeded',
+            lastBridgeEventAt: new Date().toISOString(),
+        };
+    }
+    async resolveThread(job) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const route = job.route;
+        const channelId = route.channelId;
+        const participantId = route.participantId || '';
+        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
+        if (binding?.thread_id && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, binding.thread_id)) {
+            return binding.thread_id;
+        }
+        if (route.threadId && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, route.threadId)) {
+            return route.threadId;
+        }
+        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
+        const now = new Date().toISOString();
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: job.workspaceId,
+            platform: job.platform,
+            chat_id: channelId,
+            platform_user_id: participantId,
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
+        if (authorized) {
+            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
+        }
+        return thread.id;
+    }
+    preferredAgentFor(job) {
+        const route = job.route;
+        const channelId = route.channelId;
+        if (!channelId)
+            return '';
+        const participantId = route.participantId || '';
+        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
+        return binding?.preferred_agent_type || '';
+    }
+}
+exports.BaseChannelScheduleAdapter = BaseChannelScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/lark-schedule-adapter.js

@@ -1,87 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LarkScheduleAdapter = void 0;
-const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
-const lark_execution_policies_js_1 = require("./lark-execution-policies.js");
-const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
-class LarkScheduleAdapter {
-    options;
-    executor;
+const channel_execution_policy_js_1 = require("./channel-execution-policy.js");
+const base_channel_schedule_adapter_js_1 = require("./base-channel-schedule-adapter.js");
+class LarkScheduleAdapter extends base_channel_schedule_adapter_js_1.BaseChannelScheduleAdapter {
+    platformBase = 'lark';
+    supportedRouteTypes = ['channel.chat', 'lark_chat'];
     deliveryTargets = ['lark'];
-    constructor(options) {
-        this.options = options;
-        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
-            store: options.store,
-            getWorkspaceRouter: options.getWorkspaceRouter,
+    createPolicy(job, options, resolveSameThread, preferredAgentType) {
+        const label = this.platformBase.charAt(0).toUpperCase() + this.platformBase.slice(1);
+        return (0, channel_execution_policy_js_1.createChannelExecutionPolicy)(job, options, {
+            platformBase: this.platformBase,
+            resolveSameThread,
+            sideThreadTitle: (nextJob) => `[Scheduled:${label}] ${nextJob.description || nextJob.id}`,
+            legacySideThreadTitles: (nextJob) => [`[Scheduled] ${nextJob.description || nextJob.id}`],
+            preferredAgentType,
         });
     }
-    supports(job) {
-        return (0, scheduled_job_route_js_1.platformMatches)(job.platform, 'lark') && (job.route.type === 'channel.chat' || job.route.type === 'lark_chat');
-    }
-    async execute(context) {
-        const { job } = context;
-        const executionPolicy = (0, lark_execution_policies_js_1.createLarkExecutionPolicy)(job, {
-            store: this.options.store,
-            workspaceRouter: this.options.getWorkspaceRouter(),
-            getChannelRuntime: this.options.getChannelRuntime,
-        }, (nextJob) => this.resolveThread(nextJob), (nextJob) => this.preferredAgentFor(nextJob));
-        const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
-        return {
-            threadId: execution.threadId,
-            runId: execution.runId,
-            replyText: execution.replyText,
-            deliveryMode: 'bridge-stream',
-            deliveryStatus: 'succeeded',
-            lastBridgeEventAt: new Date().toISOString(),
-        };
-    }
-    async resolveThread(job) {
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        const route = job.route;
-        const channelId = route.channelId;
-        const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
-        if (binding?.thread_id && await this.threadExists(binding.thread_id)) {
-            return binding.thread_id;
-        }
-        if (route.threadId && await this.threadExists(route.threadId)) {
-            return route.threadId;
-        }
-        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
-        const now = new Date().toISOString();
-        this.options.store.upsertPlatformThreadBinding({
-            workspace_id: job.workspaceId,
-            platform: job.platform,
-            chat_id: channelId,
-            platform_user_id: participantId,
-            thread_id: thread.id,
-            last_platform_message_id: null,
-            created_at: now,
-            updated_at: now,
-        });
-        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
-        if (authorized) {
-            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
-        }
-        return thread.id;
-    }
-    async threadExists(threadId) {
-        try {
-            await this.options.getWorkspaceRouter().getThread(threadId);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    preferredAgentFor(job) {
-        const route = job.route;
-        const channelId = route.channelId;
-        if (!channelId)
-            return '';
-        const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
-        return binding?.preferred_agent_type || '';
-    }
 }
 exports.LarkScheduleAdapter = LarkScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/local-schedule-adapter.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalScheduleAdapter = void 0;
 const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
+const thread_resolution_js_1 = require("./thread-resolution.js");
 class LocalScheduleAdapter {
     options;
     executor;
@@ -40,7 +41,7 @@ class LocalScheduleAdapter {
     }
     async resolveThread(job) {
         const workspaceRouter = this.options.getWorkspaceRouter();
-        if (job.route.threadId && await this.threadExists(job.route.threadId)) {
+        if (job.route.threadId && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, job.route.threadId)) {
             return job.route.threadId;
         }
         const title = `[Scheduled] ${job.description || job.id}`;
@@ -52,14 +53,5 @@ class LocalScheduleAdapter {
         const created = await workspaceRouter.createThread(job.workspaceId, title);
         return created.id;
     }
-    async threadExists(threadId) {
-        try {
-            await this.options.getWorkspaceRouter().getThread(threadId);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
 }
 exports.LocalScheduleAdapter = LocalScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/run-polling.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForRunCompletion = waitForRunCompletion;
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+const RUN_POLL_INTERVAL_MS = 300;
+async function waitForRunCompletion(store, runId, timeoutMs, label) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const run = store.getRun(runId);
+        if (run && TERMINAL_RUN_STATES.has(run.status)) {
+            if (run.status !== 'completed') {
+                throw new Error(`${label} run finished with status ${run.status}`);
+            }
+            return run;
+        }
+        await new Promise((resolve) => setTimeout(resolve, RUN_POLL_INTERVAL_MS));
+    }
+    throw new Error(`Timed out waiting for ${label.toLowerCase()} run ${runId}`);
+}

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-conversation-executor.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduledConversationExecutor = void 0;
 const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
-const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+const run_polling_js_1 = require("./run-polling.js");
 const SCHEDULED_RUN_PERMISSION_MODE = 'bypassPermissions';
 class ScheduledConversationExecutor {
     options;
@@ -16,9 +16,9 @@ class ScheduledConversationExecutor {
             const workspaceRouter = this.options.getWorkspaceRouter();
             const sendResult = await workspaceRouter.sendThreadMessage(target.threadId, prompt, {
                 permissionMode: SCHEDULED_RUN_PERMISSION_MODE,
-                runtimeEnv: this.buildScheduledRuntimeEnv(target),
+                runtimeEnv: (0, scheduled_job_route_js_1.buildPlatformRuntimeEnv)(target.platform, target.route),
             });
-            await this.waitForRun(sendResult.runId, timeoutMs);
+            await (0, run_polling_js_1.waitForRunCompletion)(this.options.store, sendResult.runId, timeoutMs, 'Scheduled');
             const thread = await workspaceRouter.getThread(target.threadId);
             const replyText = [...thread.messages]
                 .reverse()
@@ -34,39 +34,5 @@ class ScheduledConversationExecutor {
             await policy.afterExecute?.(target, job);
         }
     }
-    buildScheduledRuntimeEnv(target) {
-        const route = target.route;
-        const basePlatform = (0, scheduled_job_route_js_1.getChannelPlatformBase)(target.platform);
-        const env = {};
-        if (basePlatform && basePlatform !== 'local') {
-            env.LOCAL_AI_PLATFORM = basePlatform;
-            env.LOCAL_AI_ROUTE_TYPE = (0, scheduled_job_route_js_1.routeTypeForPlatform)(target.platform);
-        }
-        const instanceId = route.instanceId || (0, scheduled_job_route_js_1.getChannelPlatformInstanceId)(target.platform);
-        if (instanceId) {
-            env.LOCAL_AI_PLATFORM_INSTANCE_ID = instanceId;
-        }
-        if (route.channelId) {
-            env.LOCAL_AI_CHAT_ID = route.channelId;
-        }
-        if (route.participantId) {
-            env.LOCAL_AI_PLATFORM_USER_ID = route.participantId;
-        }
-        return env;
-    }
-    async waitForRun(runId, timeoutMs) {
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < timeoutMs) {
-            const run = this.options.store.getRun(runId);
-            if (run && TERMINAL_RUN_STATES.has(run.status)) {
-                if (run.status !== 'completed') {
-                    throw new Error(`Scheduled run finished with status ${run.status}`);
-                }
-                return run;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 300));
-        }
-        throw new Error(`Timed out waiting for scheduled run ${runId}`);
-    }
 }
 exports.ScheduledConversationExecutor = ScheduledConversationExecutor;

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-job-route.js

@@ -6,6 +6,7 @@ exports.getChannelPlatformInstanceId = getChannelPlatformInstanceId;
 exports.platformMatches = platformMatches;
 exports.routeWithPlatformInstance = routeWithPlatformInstance;
 exports.routeTypeForPlatform = routeTypeForPlatform;
+exports.buildPlatformRuntimeEnv = buildPlatformRuntimeEnv;
 exports.routeFromPlatformThreadBinding = routeFromPlatformThreadBinding;
 exports.scheduledJobMatchesPlatformBinding = scheduledJobMatchesPlatformBinding;
 exports.scheduledJobMatchesCliContext = scheduledJobMatchesCliContext;
@@ -32,6 +33,25 @@ function routeTypeForPlatform(platform) {
     const base = getChannelPlatformBase(platform);
     return base === 'lark' || base === 'weixin' ? 'channel.chat' : base;
 }
+function buildPlatformRuntimeEnv(platform, route) {
+    const basePlatform = getChannelPlatformBase(platform);
+    const env = {};
+    if (basePlatform && basePlatform !== 'local') {
+        env.LOCAL_AI_PLATFORM = basePlatform;
+        env.LOCAL_AI_ROUTE_TYPE = routeTypeForPlatform(platform);
+    }
+    const instanceId = route.instanceId || getChannelPlatformInstanceId(platform);
+    if (instanceId) {
+        env.LOCAL_AI_PLATFORM_INSTANCE_ID = instanceId;
+    }
+    if (route.channelId) {
+        env.LOCAL_AI_CHAT_ID = route.channelId;
+    }
+    if (route.participantId) {
+        env.LOCAL_AI_PLATFORM_USER_ID = route.participantId;
+    }
+    return env;
+}
 function routeFromPlatformThreadBinding(binding) {
     return {
         type: routeTypeForPlatform(binding.platform),

package/dist-electron/services/local-ai-core/src/scheduler/scheduler-service.js

@@ -16,10 +16,18 @@ class SchedulerService extends node_events_1.EventEmitter {
         this.options = options;
         this.runLifecycle = new scheduler_run_lifecycle_js_1.SchedulerRunLifecycle({
             store: options.store,
-            emitRun: (run) => this.emit('run', run),
-            emitJob: (job) => this.emit('job', job),
+            emitRun: (run) => this.emitRun(run),
+            emitJob: (job) => this.emitJob(job),
         });
     }
+    emitJob(job) {
+        this.emit('job', job);
+        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+    }
+    emitRun(run) {
+        this.emit('run', run);
+        this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: run });
+    }
     async start() {
         await this.tick();
         this.timer = setInterval(() => {
@@ -41,14 +49,12 @@ class SchedulerService extends node_events_1.EventEmitter {
     }
     createJob(input) {
         const job = this.options.store.createScheduledJob(input);
-        this.emit('job', job);
-        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+        this.emitJob(job);
         return job;
     }
     updateJob(jobId, input) {
         const job = this.options.store.updateScheduledJob(this.resolveRequiredJobId(jobId), input);
-        this.emit('job', job);
-        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+        this.emitJob(job);
         return job;
     }
     deleteJob(jobId) {
@@ -115,39 +121,21 @@ class SchedulerService extends node_events_1.EventEmitter {
     }
     async executeJob(job, triggeredAt, manual) {
         if (this.runningJobs.has(job.id)) {
-            const skipped = this.runLifecycle.markSkipped(job, triggeredAt, 'Skipped because the previous run is still active.');
-            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: skipped });
-            return skipped;
+            return this.runLifecycle.markSkipped(job, triggeredAt, 'Skipped because the previous run is still active.');
         }
         this.runningJobs.add(job.id);
         const run = this.runLifecycle.markQueued(job, triggeredAt);
-        this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: run });
         try {
             const executor = this.options.executors.find((candidate) => candidate.supports(job));
             if (!executor) {
                 throw new Error(`No scheduler executor is available for delivery target "${job.platform}"`);
             }
             this.runLifecycle.markRunning(run.id);
-            const running = this.options.store.getScheduledJobRun(run.id);
-            if (running) {
-                this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: running });
-            }
             const result = await executor.execute({ job, triggeredAt });
-            const succeeded = this.runLifecycle.markSucceeded(job, run.id, result, !manual && job.triggerType === 'once');
-            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: succeeded });
-            const nextJob = this.options.store.getScheduledJob(job.id);
-            if (nextJob) {
-                this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: nextJob });
-            }
-            return succeeded;
+            return this.runLifecycle.markSucceeded(job, run.id, result, !manual && job.triggerType === 'once');
         }
         catch (error) {
             const failed = this.runLifecycle.markFailed(job.id, run.id, error instanceof Error ? error.message : String(error));
-            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: failed });
-            const nextJob = this.options.store.getScheduledJob(job.id);
-            if (nextJob) {
-                this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: nextJob });
-            }
             this.options.log?.(`scheduler job failed ${job.id}: ${failed.error || 'unknown error'}`);
             this.maybeAutoDisableAfterFailure(job.id);
             return failed;
@@ -173,8 +161,7 @@ class SchedulerService extends node_events_1.EventEmitter {
         this.options.store.updateScheduledJobStatus(jobId, { enabled: false });
         const disabled = this.options.store.getScheduledJob(jobId);
         if (disabled) {
-            this.emit('job', disabled);
-            this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: disabled });
+            this.emitJob(disabled);
         }
         this.options.log?.(`scheduler auto-disabled job ${jobId} after ${consecutiveFailures} consecutive failures`);
     }