@kafca/agentdock 0.1.33 → 0.1.35

package/dist-electron/services/local-ai-core/src/runtime/local-core-controller.js

@@ -4,7 +4,6 @@ exports.LocalCoreController = void 0;
 const node_events_1 = require("node:events");
 const desktop_js_1 = require("../../../../shared/desktop.js");
 const bootstrap_js_1 = require("../kernel/bootstrap.js");
-const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
 const runtime_detection_service_js_1 = require("./runtime-detection-service.js");
 class LocalCoreController extends node_events_1.EventEmitter {
     userDataPath;
@@ -12,7 +11,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
     workspaceRouter;
     knowledgeProvider;
     channelRuntimes;
-    scheduler;
+    scheduledJobs;
     kernel;
     runtime;
     runtimeDetection;
@@ -33,7 +32,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
         this.workspaceRouter = this.runtime.workspaceRouter;
         const runtimeChannels = this.runtime.channelRuntimes || [this.runtime.channelRuntime, this.runtime.weixinChannelRuntime];
         this.channelRuntimes = new Map(runtimeChannels.filter(Boolean).map((runtime) => [runtime.platform, runtime]));
-        this.scheduler = this.runtime.scheduler;
+        this.scheduledJobs = this.runtime.scheduledJobs;
         this.runtimeDetection = new runtime_detection_service_js_1.RuntimeDetectionService({
             userDataPath,
             readConfig: async () => (await this.readConfigFile()).parsed,
@@ -106,6 +105,9 @@ class LocalCoreController extends node_events_1.EventEmitter {
     getLogs(limit = 200) {
         return this.state.getLogs(limit);
     }
+    getLogEntries(level = 'sys', limit = 200) {
+        return this.state.getLogEntries(level, limit);
+    }
     async readConfigFile() {
         return this.state.readConfigFile();
     }
@@ -182,63 +184,29 @@ class LocalCoreController extends node_events_1.EventEmitter {
         return this.workspaceRouter.listAuditEvents(query);
     }
     async listScheduledJobs(workspaceId) {
-        return this.scheduler.listJobs(workspaceId);
+        return this.scheduledJobs.listJobs(workspaceId);
     }
     async getScheduledJob(jobId) {
-        const job = this.scheduler.getJob(jobId);
+        const job = this.scheduledJobs.getJob(jobId);
         if (!job) {
             throw new Error(`Scheduled job not found: ${jobId}`);
         }
         return job;
     }
     async createScheduledJob(input) {
-        return this.scheduler.createJob(this.resolveScheduledJobCreateInput(input));
-    }
-    resolveScheduledJobCreateInput(input) {
-        if (input.platform && input.route) {
-            return {
-                ...input,
-                route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route),
-            };
-        }
-        const threadId = String(input.threadId || input.route?.threadId || '').trim();
-        if (threadId) {
-            const binding = this.runtime.store.getPlatformThreadBindingByThreadId(threadId);
-            if (binding && binding.workspace_id === input.workspaceId) {
-                return {
-                    ...input,
-                    platform: binding.platform,
-                    route: {
-                        type: 'channel.chat',
-                        channelId: binding.chat_id,
-                        participantId: binding.platform_user_id,
-                    },
-                };
-            }
-        }
-        return {
-            ...input,
-            platform: 'local',
-            route: {
-                type: 'local.thread',
-                channelId: input.workspaceId,
-            },
-        };
+        return this.scheduledJobs.createJob(input);
     }
     async updateScheduledJob(jobId, input) {
-        return this.scheduler.updateJob(jobId, {
-            ...input,
-            ...(input.route ? { route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) } : {}),
-        });
+        return this.scheduledJobs.updateJob(jobId, input);
     }
     async deleteScheduledJob(jobId) {
-        return this.scheduler.deleteJob(jobId);
+        return this.scheduledJobs.deleteJob(jobId);
     }
     async runScheduledJob(jobId) {
-        return this.scheduler.runJobNow(jobId);
+        return this.scheduledJobs.runJobNow(jobId);
     }
     async listScheduledJobRuns(jobId) {
-        return this.scheduler.listJobRuns(jobId);
+        return this.scheduledJobs.listJobRuns(jobId);
     }
     async listThreads(workspaceId) {
         return this.workspaceRouter.listThreads(workspaceId);

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

@@ -37,13 +37,10 @@ exports.createLocalCoreRuntimeState = createLocalCoreRuntimeState;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const TOML = __importStar(require("@iarna/toml"));
+const rotating_logger_js_1 = require("../kernel/rotating-logger.js");
 const DEFAULT_CONFIG = `# Managed by Local AI Core
 # Add [[projects]] entries from the workspace page before starting a conversation.
 `;
-const LOG_FILE_NAME = 'local-core.log';
-const LOG_FILE_MAX_BYTES = 2 * 1024 * 1024;
-const LOG_TAIL_CHUNK_BYTES = 64 * 1024;
-const LOG_MAX_RETURN_LINES = 5000;
 class FileBackedLocalCoreRuntimeState {
     userDataPath;
     onLog;
@@ -53,12 +50,14 @@ class FileBackedLocalCoreRuntimeState {
     logPath;
     settings;
     logs = [];
+    logger;
     constructor(userDataPath, onLog) {
         this.userDataPath = userDataPath;
         this.onLog = onLog;
         this.runtimeDir = (0, node_path_1.join)(userDataPath, 'runtime');
         this.settingsPath = (0, node_path_1.join)(this.runtimeDir, 'local-core-settings.json');
-        this.logPath = (0, node_path_1.join)(this.runtimeDir, LOG_FILE_NAME);
+        this.logger = new rotating_logger_js_1.AgentDockRotatingLogger({ scope: 'local-ai-core' });
+        this.logPath = this.logger.sysLogPath;
         (0, node_fs_1.mkdirSync)(this.runtimeDir, { recursive: true });
         this.cliBinDir = this.ensureCliWrapper();
         this.settings = this.loadSettings();
@@ -114,43 +113,25 @@ class FileBackedLocalCoreRuntimeState {
         return this.settings.knowledge;
     }
     getLogs(limit = 200) {
-        const normalizedLimit = normalizeLogLimit(limit);
-        const current = tailLogFile(this.logPath, normalizedLimit);
-        if (current.length >= normalizedLimit) {
-            return current.slice(-normalizedLimit);
-        }
-        const rotated = tailLogFile(`${this.logPath}.1`, normalizedLimit - current.length);
-        return [...rotated, ...current].slice(-normalizedLimit);
+        return this.logger.tailSysLog(limit);
+    }
+    getLogEntries(level = 'sys', limit = 200) {
+        const normalizedLevel = normalizeLogFile(level);
+        return this.logger.tail(normalizedLevel, limit)
+            .map(parseLogEntry)
+            .filter((entry) => Boolean(entry));
     }
     pushLog(message) {
         if (!message) {
             return;
         }
         this.logs.push(message);
-        this.appendLogFile(message);
+        this.logger.write((0, rotating_logger_js_1.inferLogLevel)(message), message);
         this.onLog?.(message);
         if (this.logs.length > 400) {
             this.logs.splice(0, this.logs.length - 400);
         }
     }
-    appendLogFile(message) {
-        try {
-            if ((0, node_fs_1.existsSync)(this.logPath) && (0, node_fs_1.statSync)(this.logPath).size > LOG_FILE_MAX_BYTES) {
-                const rotatedPath = `${this.logPath}.1`;
-                try {
-                    (0, node_fs_1.renameSync)(this.logPath, rotatedPath);
-                }
-                catch {
-                    // Keep runtime logging best-effort; stdout/UI logs still work.
-                }
-            }
-            const line = `${new Date().toISOString()} ${message.replace(/\r?\n/g, '\\n')}\n`;
-            (0, node_fs_1.appendFileSync)(this.logPath, line, 'utf-8');
-        }
-        catch {
-            // File logging must never break Local AI Core runtime behavior.
-        }
-    }
     async readConfigFile() {
         const path = this.settings.configPath;
         if (!(0, node_fs_1.existsSync)(path)) {
@@ -262,6 +243,34 @@ class FileBackedLocalCoreRuntimeState {
         return binDir;
     }
 }
+function normalizeLogFile(level) {
+    if (level === 'debug' || level === 'info' || level === 'warn' || level === 'error') {
+        return level;
+    }
+    return 'sys';
+}
+function parseLogEntry(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const level = normalizeLogFile(String(parsed.level || 'info'));
+        if (level === 'sys') {
+            return null;
+        }
+        return {
+            ts: String(parsed.ts || ''),
+            level,
+            scope: String(parsed.scope || ''),
+            message: String(parsed.message || ''),
+            ...(parsed.meta && typeof parsed.meta === 'object' ? { meta: parsed.meta } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function normalizePluginSettings(input) {
     if (!input || typeof input !== 'object') {
         return {};
@@ -281,59 +290,6 @@ function normalizePluginSettings(input) {
     }
     return output;
 }
-function normalizeLogLimit(limit) {
-    if (!Number.isFinite(limit)) {
-        return 200;
-    }
-    return Math.min(Math.max(Math.floor(limit), 1), LOG_MAX_RETURN_LINES);
-}
-function tailLogFile(path, limit) {
-    if (limit <= 0 || !(0, node_fs_1.existsSync)(path)) {
-        return [];
-    }
-    let fd = -1;
-    try {
-        const size = (0, node_fs_1.statSync)(path).size;
-        if (size <= 0) {
-            return [];
-        }
-        fd = (0, node_fs_1.openSync)(path, 'r');
-        const chunks = [];
-        let position = size;
-        let newlineCount = 0;
-        while (position > 0 && newlineCount <= limit) {
-            const bytesToRead = Math.min(LOG_TAIL_CHUNK_BYTES, position);
-            position -= bytesToRead;
-            const chunk = Buffer.allocUnsafe(bytesToRead);
-            const bytesRead = (0, node_fs_1.readSync)(fd, chunk, 0, bytesToRead, position);
-            const slice = bytesRead === bytesToRead ? chunk : chunk.subarray(0, bytesRead);
-            chunks.unshift(slice);
-            for (let index = 0; index < slice.length; index += 1) {
-                if (slice[index] === 10) {
-                    newlineCount += 1;
-                }
-            }
-        }
-        return Buffer.concat(chunks)
-            .toString('utf8')
-            .split(/\r?\n/)
-            .filter((line) => line.length > 0)
-            .slice(-limit);
-    }
-    catch {
-        return [];
-    }
-    finally {
-        if (fd >= 0) {
-            try {
-                (0, node_fs_1.closeSync)(fd);
-            }
-            catch {
-                // Log reads are best-effort; failed closes cannot be surfaced to callers.
-            }
-        }
-    }
-}
 function createLocalCoreRuntimeState(options) {
     return new FileBackedLocalCoreRuntimeState(options.userDataPath, options.onLog);
 }

package/dist-electron/services/local-ai-core/src/runtime/server-routes.js

@@ -23,6 +23,9 @@ function parseLocalAiCoreRoute(method, path) {
     if (normalizedMethod === 'GET' && relativePath === '/runtime/logs') {
         return { name: 'runtime.logs' };
     }
+    if (normalizedMethod === 'GET' && relativePath === '/logs') {
+        return { name: 'logs.list' };
+    }
     if (normalizedMethod === 'GET' && relativePath === '/runtime/agent-runtimes') {
         return { name: 'runtime.agent-runtimes' };
     }

package/dist-electron/services/local-ai-core/src/runtime/server.js

@@ -143,6 +143,20 @@ class LocalAiCoreServer {
                 json(res, 200, this.bindings.getLogs(limit));
                 return;
             }
+            case 'logs.list': {
+                const level = url.searchParams.get('level') || 'sys';
+                const limit = Number(url.searchParams.get('limit') || '200');
+                json(res, 200, {
+                    entries: this.bindings.getLogEntries(level, limit).map((entry) => ({
+                        time: entry.ts,
+                        level: entry.level,
+                        scope: entry.scope,
+                        message: entry.message,
+                        meta: entry.meta,
+                    })),
+                });
+                return;
+            }
             case 'runtime.agent-runtimes':
             case 'runtimes.list':
                 json(res, 200, await this.runtimeDetectionResponse());

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

@@ -16,7 +16,7 @@ class LarkScheduleAdapter {
         });
     }
     supports(job) {
-        return job.platform === 'lark' && (job.route.type === 'channel.chat' || job.route.type === 'lark_chat');
+        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;
@@ -32,7 +32,7 @@ class LarkScheduleAdapter {
             if (!channelRuntime.sendScheduledMessage) {
                 throw new Error('Lark channel runtime does not support scheduled delivery.');
             }
-            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), execution.replyText);
+            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), job.platform), execution.replyText);
             if (!platformMessageId) {
                 throw new Error('Lark gateway did not return a message id for scheduled delivery.');
             }
@@ -49,7 +49,7 @@ class LarkScheduleAdapter {
         const route = job.route;
         const channelId = route.channelId;
         const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, 'lark');
+        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;
         }
@@ -60,6 +60,7 @@ class LarkScheduleAdapter {
         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,
@@ -67,9 +68,9 @@ class LarkScheduleAdapter {
             created_at: now,
             updated_at: now,
         });
-        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId);
+        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
         if (authorized) {
-            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id);
+            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
         }
         return thread.id;
     }

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

@@ -1,6 +1,7 @@
 "use strict";
 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 SCHEDULED_RUN_PERMISSION_MODE = 'bypassPermissions';
 class ScheduledConversationExecutor {
@@ -14,6 +15,7 @@ class ScheduledConversationExecutor {
         try {
             const sendResult = await this.options.workspaceRouter.sendThreadMessage(target.threadId, prompt, {
                 permissionMode: SCHEDULED_RUN_PERMISSION_MODE,
+                runtimeEnv: this.buildScheduledRuntimeEnv(target),
             });
             await this.waitForRun(sendResult.runId, timeoutMs);
             const thread = await this.options.workspaceRouter.getThread(target.threadId);
@@ -31,6 +33,26 @@ 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) {

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledJobApplicationService = void 0;
+const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
+class ScheduledJobApplicationService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    listJobs(workspaceId) {
+        return this.options.scheduler.listJobs(workspaceId);
+    }
+    getJob(jobId) {
+        return this.options.scheduler.getJob(jobId);
+    }
+    createJob(input) {
+        return this.options.scheduler.createJob(this.resolveCreateInput(input));
+    }
+    createCronJob(input) {
+        return this.options.scheduler.createJob({
+            workspaceId: input.workspaceId,
+            platform: input.platform,
+            route: this.resolveExplicitRoute(input.platform, input.route),
+            triggerType: 'cron',
+            cronExpr: input.schedule,
+            promptTemplate: input.message,
+            description: `${input.name} · ${input.scheduleDescription}`,
+            enabled: true,
+        });
+    }
+    updateJob(jobId, input) {
+        return this.options.scheduler.updateJob(jobId, {
+            ...input,
+            ...(input.route ? { route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) } : {}),
+        });
+    }
+    deleteJob(jobId) {
+        return this.options.scheduler.deleteJob(jobId);
+    }
+    runJobNow(jobId) {
+        return this.options.scheduler.runJobNow(jobId);
+    }
+    listJobRuns(jobId) {
+        return this.options.scheduler.listJobRuns(jobId);
+    }
+    listJobsForThread(threadId) {
+        const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+        return this.options.scheduler
+            .listJobs()
+            .filter((job) => job.route.threadId === threadId ||
+            (binding ? (0, scheduled_job_route_js_1.scheduledJobMatchesPlatformBinding)(job, binding) : false));
+    }
+    resolveCreateInput(input) {
+        if (input.platform && input.route) {
+            return {
+                ...input,
+                route: this.resolveExplicitRoute(input.platform, input.route),
+            };
+        }
+        const threadId = String(input.threadId || input.route?.threadId || '').trim();
+        if (threadId) {
+            const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+            if (binding && binding.workspace_id === input.workspaceId) {
+                return {
+                    ...input,
+                    platform: binding.platform,
+                    route: (0, scheduled_job_route_js_1.routeFromPlatformThreadBinding)(binding),
+                };
+            }
+        }
+        return {
+            ...input,
+            platform: 'local',
+            route: {
+                type: 'local.thread',
+                channelId: input.workspaceId,
+            },
+        };
+    }
+    resolveExplicitRoute(platform, route) {
+        return (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(route), platform);
+    }
+}
+exports.ScheduledJobApplicationService = ScheduledJobApplicationService;

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

@@ -1,15 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withoutThreadRoute = withoutThreadRoute;
+exports.getChannelPlatformBase = getChannelPlatformBase;
+exports.getChannelPlatformInstanceId = getChannelPlatformInstanceId;
+exports.platformMatches = platformMatches;
+exports.routeWithPlatformInstance = routeWithPlatformInstance;
+exports.routeTypeForPlatform = routeTypeForPlatform;
+exports.routeFromPlatformThreadBinding = routeFromPlatformThreadBinding;
 exports.scheduledJobMatchesPlatformBinding = scheduledJobMatchesPlatformBinding;
 exports.scheduledJobMatchesCliContext = scheduledJobMatchesCliContext;
 function withoutThreadRoute(route) {
     const { threadId: _threadId, ...deliveryRoute } = route;
     return deliveryRoute;
 }
+function getChannelPlatformBase(platform) {
+    return String(platform || '').trim().toLowerCase().split(':', 1)[0] || '';
+}
+function getChannelPlatformInstanceId(platform) {
+    const normalized = String(platform || '').trim().toLowerCase();
+    const separator = normalized.indexOf(':');
+    return separator >= 0 ? normalized.slice(separator + 1) : '';
+}
+function platformMatches(candidate, expectedBase) {
+    return getChannelPlatformBase(candidate) === expectedBase;
+}
+function routeWithPlatformInstance(route, platform) {
+    const instanceId = route.instanceId || getChannelPlatformInstanceId(platform);
+    return instanceId ? { ...route, instanceId } : route;
+}
+function routeTypeForPlatform(platform) {
+    const base = getChannelPlatformBase(platform);
+    return base === 'lark' || base === 'weixin' ? 'channel.chat' : base;
+}
+function routeFromPlatformThreadBinding(binding) {
+    return {
+        type: routeTypeForPlatform(binding.platform),
+        channelId: binding.chat_id,
+        instanceId: getChannelPlatformInstanceId(binding.platform) || undefined,
+        participantId: binding.platform_user_id,
+    };
+}
 function scheduledJobMatchesPlatformBinding(job, binding) {
     return (job.workspaceId === binding.workspace_id &&
-        job.platform === binding.platform &&
+        getChannelPlatformBase(job.platform) === getChannelPlatformBase(binding.platform) &&
         job.route.channelId === binding.chat_id &&
         String(job.route.participantId || '') === String(binding.platform_user_id || ''));
 }
@@ -18,7 +51,7 @@ function scheduledJobMatchesCliContext(job, context) {
         return false;
     }
     return (job.workspaceId === context.workspaceId &&
-        job.platform === context.platform &&
+        getChannelPlatformBase(job.platform) === getChannelPlatformBase(context.platform) &&
         job.route.channelId === context.chatId &&
         String(job.route.participantId || '') === String(context.platformUserId || ''));
 }

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

@@ -16,7 +16,7 @@ class WeixinScheduleAdapter {
         });
     }
     supports(job) {
-        return job.platform === 'weixin' && (job.route.type === 'channel.chat' || job.route.type === 'weixin_chat');
+        return (0, scheduled_job_route_js_1.platformMatches)(job.platform, 'weixin') && (job.route.type === 'channel.chat' || job.route.type === 'weixin_chat');
     }
     async execute(context) {
         const { job } = context;
@@ -32,7 +32,7 @@ class WeixinScheduleAdapter {
             if (!channelRuntime.sendScheduledMessage) {
                 throw new Error('WeChat channel runtime does not support scheduled delivery.');
             }
-            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), execution.replyText);
+            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), job.platform), execution.replyText);
             if (!platformMessageId) {
                 throw new Error('WeChat gateway did not return a message id for scheduled delivery.');
             }
@@ -49,7 +49,7 @@ class WeixinScheduleAdapter {
         const route = job.route;
         const channelId = route.channelId;
         const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, 'weixin');
+        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;
         }
@@ -68,9 +68,9 @@ class WeixinScheduleAdapter {
             created_at: now,
             updated_at: now,
         });
-        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, 'weixin');
+        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
         if (authorized) {
-            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, 'weixin');
+            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
         }
         return thread.id;
     }

package/dist-electron/src/api/client.js

@@ -14,7 +14,7 @@ class ApiClient {
             this.baseUrl = DEFAULT_API_BASE;
             return;
         }
-        this.baseUrl = trimmed.endsWith('/api/v1')
+        this.baseUrl = trimmed.endsWith('/api/v1') || trimmed.endsWith('/api/local/v1')
             ? trimmed
             : `${trimmed.replace(/\/+$/, '')}/api/v1`;
     }

package/dist-electron/tests/electron/lac-cli.test.js

@@ -214,6 +214,56 @@ function createIo() {
     });
     strict_1.default.match(read().stdout, /Sent file out\.pdf to chat-1: msg-file-1/);
 });
+(0, node_test_1.default)('lac channel send-file normalizes instance-qualified platform env into route instance', async () => {
+    let capturedUrl = '';
+    let capturedBody = null;
+    const server = (0, node_http_1.createServer)(async (req, res) => {
+        if (req.method === 'POST') {
+            capturedUrl = req.url || '';
+            const chunks = [];
+            for await (const chunk of req) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            capturedBody = Buffer.concat(chunks).toString('utf8');
+            res.setHeader('content-type', 'application/json');
+            res.end(JSON.stringify({
+                ok: true,
+                data: {
+                    platform: 'lark',
+                    workspaceId: '知识库',
+                    channelId: 'chat-1',
+                    messageIds: ['msg-file-1'],
+                    attachments: [{ kind: 'file', fileName: 'out.pdf', fileSize: 123 }],
+                },
+            }));
+            return;
+        }
+        res.statusCode = 404;
+        res.end(JSON.stringify({ ok: false, error: 'not found' }));
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    (0, strict_1.default)(address && typeof address === 'object');
+    const { io } = createIo();
+    const exitCode = await (0, lac_js_1.runCli)(['channel', 'send-file', '--path', 'reports/out.pdf'], {
+        LOCAL_AI_CORE_BASE: `http://127.0.0.1:${address.port}/api/local/v1`,
+        LOCAL_AI_WORKSPACE_ID: '知识库',
+        LOCAL_AI_WORKSPACE_PATH: '/workspace/project',
+        LOCAL_AI_PLATFORM: 'lark:lark-1',
+        LOCAL_AI_CHAT_ID: 'chat-1',
+        LOCAL_AI_PLATFORM_USER_ID: 'user-1',
+    }, io);
+    server.close();
+    strict_1.default.equal(exitCode, 0);
+    strict_1.default.equal(capturedUrl, '/api/local/v1/platforms/lark/%E7%9F%A5%E8%AF%86%E5%BA%93/messages');
+    (0, strict_1.default)(capturedBody);
+    strict_1.default.deepEqual(JSON.parse(capturedBody).route, {
+        type: 'channel.chat',
+        channelId: 'chat-1',
+        instanceId: 'lark-1',
+        participantId: 'user-1',
+    });
+});
 (0, node_test_1.default)('lac channel send-file posts allowed absolute paths through the same outbound message path', async () => {
     let capturedBody = null;
     const server = (0, node_http_1.createServer)(async (req, res) => {