@kafca/agentdock 0.1.33 → 0.1.34

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/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) => {

package/dist-electron/tests/electron/plugin-kernel.test.js

@@ -562,6 +562,7 @@ model = "deepseek-v4-flash"
         knowledgeAttachments: {},
         workspaceRouter: {},
         scheduler: {},
+        scheduledJobs: {},
         start: async () => {
             started = true;
         },

package/dist-electron/tests/electron/workspace-task-store.test.js

@@ -82,6 +82,50 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('scheduler create from a bound thread preserves channel instance route', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-instance-route-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        const thread = runtime.store.createThread('workspace-a', 'Lark instance thread');
+        const now = new Date().toISOString();
+        runtime.store.upsertPlatformThreadBinding({
+            workspace_id: 'workspace-a',
+            platform: 'lark:lark-1',
+            chat_id: 'chat-1',
+            platform_user_id: 'user-1',
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const job = await controller.createScheduledJob({
+            workspaceId: 'workspace-a',
+            threadId: thread.id,
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'bound lark task',
+            enabled: true,
+        });
+        strict_1.default.equal(job.platform, 'lark:lark-1');
+        strict_1.default.deepEqual(job.route, {
+            type: 'channel.chat',
+            channelId: 'chat-1',
+            instanceId: 'lark-1',
+            participantId: 'user-1',
+        });
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('Lark scheduled same-thread execution resolves the latest channel thread and keeps channel delivery', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-lark-latest-thread-'));
     try {
@@ -170,6 +214,85 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('Lark scheduled execution supports instance-qualified platform keys', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-lark-instance-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const thread = store.createThread('workspace-a', 'Lark instance thread');
+        const now = new Date().toISOString();
+        store.upsertPlatformThreadBinding({
+            workspace_id: 'workspace-a',
+            platform: 'lark:lark-1',
+            chat_id: 'chat-1',
+            platform_user_id: 'user-1',
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const job = store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'lark:lark-1',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1' },
+            executionMode: 'same-thread',
+            triggerType: 'cron',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'bound lark task',
+            enabled: true,
+        });
+        let deliveredRoute;
+        const adapter = new lark_schedule_adapter_js_1.LarkScheduleAdapter({
+            store,
+            getWorkspaceRouter: () => ({
+                getThread: async (threadId) => ({
+                    id: threadId,
+                    workspaceId: 'workspace-a',
+                    title: 'Thread',
+                    live: false,
+                    updatedAt: now,
+                    createdAt: now,
+                    historyCount: 1,
+                    excerpt: '',
+                    bridgeSessionKey: '',
+                    agentType: 'localcore-acp',
+                    selectedKnowledgeBaseIds: [],
+                    pendingPermissionRequest: null,
+                    messages: [{ id: 'message-1', role: 'assistant', kind: 'final', content: 'pong', timestamp: now }],
+                }),
+                sendThreadMessage: async (threadId, _prompt, options) => {
+                    strict_1.default.equal(threadId, thread.id);
+                    strict_1.default.equal(options?.runtimeEnv?.LOCAL_AI_PLATFORM, 'lark');
+                    strict_1.default.equal(options?.runtimeEnv?.LOCAL_AI_PLATFORM_INSTANCE_ID, 'lark-1');
+                    strict_1.default.equal(options?.runtimeEnv?.LOCAL_AI_CHAT_ID, 'chat-1');
+                    store.updateRun('run-1', threadId, 'completed');
+                    return { runId: 'run-1' };
+                },
+            }),
+            getChannelRuntime: () => ({
+                muteThreadBridge: () => { },
+                unmuteThreadBridge: () => { },
+                sendScheduledMessage: async (_workspaceId, route) => {
+                    deliveredRoute = route;
+                    return 'platform-message-1';
+                },
+            }),
+        });
+        const result = await adapter.execute({ job, triggeredAt: now });
+        strict_1.default.equal(result.threadId, thread.id);
+        strict_1.default.equal(result.platformMessageId, 'platform-message-1');
+        strict_1.default.deepEqual(deliveredRoute, {
+            type: 'channel.chat',
+            channelId: 'chat-1',
+            instanceId: 'lark-1',
+            participantId: 'user-1',
+        });
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('ACP runtime env includes the current workspace path for file returns', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-env-'));
     try {

package/dist-electron/tests/integration/local-core-refactor.test.js

@@ -3512,11 +3512,12 @@ const server_routes_js_1 = require("../../services/local-ai-core/src/runtime/ser
 });
 (0, node_test_1.default)('scheduled conversation executor uses execution policy hooks around a thread run', async () => {
     const calls = [];
+    let runtimeEnv;
     const job = {
         id: 'job-1',
         workspaceId: '知识库',
-        platform: 'lark',
-        route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1', threadId: 'thread-1' },
+        platform: 'lark:lark-1',
+        route: { type: 'channel.chat', channelId: 'chat-1', instanceId: 'lark-1', participantId: 'user-1', threadId: 'thread-1' },
         executionMode: 'same-thread',
         triggerType: 'cron',
         cronExpr: '*/2 * * * *',
@@ -3533,6 +3534,7 @@ const server_routes_js_1 = require("../../services/local-ai-core/src/runtime/ser
         },
         workspaceRouter: {
             sendThreadMessage: async (threadId, prompt, options) => {
+                runtimeEnv = options?.runtimeEnv;
                 calls.push(`send:${threadId}:${prompt}:${options?.permissionMode || ''}`);
                 return { runId: 'run-1' };
             },
@@ -3549,7 +3551,7 @@ const server_routes_js_1 = require("../../services/local-ai-core/src/runtime/ser
             kind: 'thread',
             threadId: 'thread-1',
             workspaceId: '知识库',
-            platform: 'lark',
+            platform: 'lark:lark-1',
             route: job.route,
         }),
         beforeExecute: (target) => {
@@ -3564,6 +3566,13 @@ const server_routes_js_1 = require("../../services/local-ai-core/src/runtime/ser
         'send:thread-1:ping:bypassPermissions',
         'after:thread-1',
     ]);
+    strict_1.default.deepEqual(runtimeEnv, {
+        LOCAL_AI_PLATFORM: 'lark',
+        LOCAL_AI_ROUTE_TYPE: 'channel.chat',
+        LOCAL_AI_PLATFORM_INSTANCE_ID: 'lark-1',
+        LOCAL_AI_CHAT_ID: 'chat-1',
+        LOCAL_AI_PLATFORM_USER_ID: 'user-1',
+    });
     strict_1.default.equal(result.replyText, 'done');
 });
 (0, node_test_1.default)('local scheduler adapter runs a workspace thread without channel delivery', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafca/agentdock",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "license": "PolyForm-Noncommercial-1.0.0",
   "type": "module",
   "main": "dist-electron/electron/main.js",

package/dist/renderer/assets/projects-B-pbhhtH.js

@@ -1 +0,0 @@
-import{z as t}from"./index-BYyDk28K.js";const e=()=>t.get("/projects"),r=o=>t.get(`/projects/${o}`);export{r as g,e as l};