@kafca/agentdock 0.1.7

package/dist-electron/services/local-ai-core/src/plugins/builtin/channel-lark-plugin.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinLarkChannelPlugin = createBuiltinLarkChannelPlugin;
+const local_core_lark_gateway_js_1 = require("../../gateway/local-core-lark-gateway.js");
+function createBuiltinLarkChannelPlugin(options) {
+    let runtime = null;
+    let unsubscribeBridgeEvents = null;
+    return {
+        manifest: {
+            id: 'builtin.channel-lark',
+            kind: 'channel',
+            version: '0.1.0',
+            provides: [
+                'channel:lark',
+            ],
+            configSchema: {
+                fields: [
+                    { key: 'appId', type: 'string', label: 'App ID' },
+                    { key: 'appSecret', type: 'string', label: 'App Secret' },
+                ],
+            },
+        },
+        capabilities: {
+            channels: [
+                {
+                    id: 'channel.lark',
+                    platform: 'lark',
+                    routeType: 'channel.chat',
+                    displayName: 'LocalCore Lark',
+                },
+            ],
+        },
+        createRuntime(ctx) {
+            if (!runtime) {
+                runtime = {
+                    channel: new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+                        store: options.store,
+                        readConfig: options.readConfig,
+                        getWorkspaceRouter: options.getWorkspaceRouter,
+                        eventBus: ctx.bus,
+                        log: options.log,
+                    }),
+                };
+                unsubscribeBridgeEvents = ctx.bus.on('platform.bridge.updated', (event) => {
+                    void runtime?.channel.onBridgeEvent?.(event);
+                });
+            }
+            return runtime;
+        },
+        async start() {
+            await runtime?.channel.refreshBindings?.();
+        },
+        async stop() {
+            unsubscribeBridgeEvents?.();
+            unsubscribeBridgeEvents = null;
+            runtime?.channel.close?.();
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/channel-weixin-plugin.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinWeixinChannelPlugin = createBuiltinWeixinChannelPlugin;
+const local_core_weixin_gateway_js_1 = require("../../gateway/local-core-weixin-gateway.js");
+function createBuiltinWeixinChannelPlugin(options) {
+    let runtime = null;
+    let unsubscribeBridgeEvents = null;
+    return {
+        manifest: {
+            id: 'builtin.channel-weixin',
+            kind: 'channel',
+            version: '0.1.0',
+            provides: [
+                'channel:weixin',
+            ],
+            configSchema: {
+                fields: [],
+            },
+        },
+        capabilities: {
+            channels: [
+                {
+                    id: 'channel.weixin',
+                    platform: 'weixin',
+                    routeType: 'channel.chat',
+                    displayName: 'LocalCore WeChat',
+                },
+            ],
+        },
+        createRuntime(ctx) {
+            if (!runtime) {
+                runtime = {
+                    channel: new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+                        store: options.store,
+                        readConfig: options.readConfig,
+                        getWorkspaceRouter: options.getWorkspaceRouter,
+                        eventBus: ctx.bus,
+                        log: options.log,
+                    }),
+                };
+                unsubscribeBridgeEvents = ctx.bus.on('platform.bridge.updated', (event) => {
+                    void runtime?.channel.onBridgeEvent?.(event);
+                });
+            }
+            return runtime;
+        },
+        async start() {
+            await runtime?.channel.refreshBindings?.();
+        },
+        async stop() {
+            unsubscribeBridgeEvents?.();
+            unsubscribeBridgeEvents = null;
+            runtime?.channel.close?.();
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/knowledge-ai-vector-plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinAiVectorKnowledgePlugin = createBuiltinAiVectorKnowledgePlugin;
+const index_js_1 = require("../../../../../packages/knowledge-api/src/index.js");
+function createBuiltinAiVectorKnowledgePlugin(options) {
+    return (0, index_js_1.createAiVectorKnowledgePlugin)(options);
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/knowledge-noop-plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinNoopKnowledgePlugin = createBuiltinNoopKnowledgePlugin;
+const index_js_1 = require("../../../../../packages/knowledge-api/src/index.js");
+function createBuiltinNoopKnowledgePlugin() {
+    return (0, index_js_1.createNoopKnowledgePlugin)();
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/runtime-capabilities-plugin.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeCapabilitiesPlugin = void 0;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+exports.runtimeCapabilitiesPlugin = {
+    manifest: {
+        id: 'builtin.runtime-capabilities',
+        kind: 'composite',
+        version: '0.1.0',
+        provides: [
+            'agent:opencode',
+            'agent:codex',
+            'agent:claudecode',
+            'agent:cursor',
+            'agent:gemini',
+            'agent:qoder',
+            'agent:iflow',
+            `agent:${desktop_js_1.LOCALCORE_ACP_AGENT_TYPE}`,
+            'channel:localcore-lark',
+            `channel:${desktop_js_1.LOCALCORE_ACP_AGENT_TYPE}`,
+            'knowledge:ai-vector',
+            'scheduler:cron',
+        ],
+    },
+    capabilities: {
+        agents: desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS.map((agentType) => ({
+            id: `agent.${agentType}`,
+            agentType,
+            displayName: agentType,
+        })),
+        channels: [
+            {
+                id: 'channel.localcore-lark',
+                platform: 'lark',
+                routeType: 'lark_chat',
+                displayName: 'LocalCore Lark',
+            },
+            {
+                id: `channel.${desktop_js_1.LOCALCORE_ACP_AGENT_TYPE}`,
+                platform: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+                displayName: 'LocalCore ACP',
+            },
+        ],
+        knowledge: [
+            {
+                id: 'knowledge.ai-vector',
+                sourceType: 'ai-vector',
+                enabled: true,
+                displayName: 'AI Vector Knowledge',
+            },
+        ],
+        schedulers: [
+            {
+                id: 'scheduler.cron',
+                triggerTypes: ['cron', 'once'],
+                deliveryPlatforms: ['lark'],
+                enabled: true,
+                displayName: 'Cron Scheduler',
+            },
+        ],
+    },
+};

package/dist-electron/services/local-ai-core/src/plugins/builtin/scheduler-cron-plugin.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinCronSchedulerPlugin = createBuiltinCronSchedulerPlugin;
+const cron_js_1 = require("../../scheduler/cron.js");
+class CronSchedulerTriggerRuntime {
+    triggerTypes = ['cron', 'once'];
+    supports(job) {
+        return job.triggerType === 'cron' || job.triggerType === 'once';
+    }
+    isDue(job, now) {
+        if (job.triggerType === 'once') {
+            return Boolean(job.runAt && Date.parse(job.runAt) <= now.getTime() && !job.lastRunAt);
+        }
+        if (!job.cronExpr) {
+            return false;
+        }
+        if (!(0, cron_js_1.cronMatchesDate)(job.cronExpr, now)) {
+            return false;
+        }
+        const minuteStart = (0, cron_js_1.floorToMinute)(now).toISOString();
+        return !job.lastRunAt || job.lastRunAt < minuteStart;
+    }
+}
+function createBuiltinCronSchedulerPlugin() {
+    return {
+        manifest: {
+            id: 'builtin.scheduler-cron',
+            kind: 'scheduler',
+            version: '0.1.0',
+            provides: ['scheduler.trigger.cron'],
+        },
+        capabilities: {
+            schedulers: [
+                {
+                    id: 'scheduler.trigger.cron',
+                    triggerTypes: ['cron', 'once'],
+                    deliveryTargets: [],
+                    enabled: true,
+                    displayName: 'Cron Trigger',
+                },
+            ],
+        },
+        createRuntime() {
+            return {
+                triggers: [new CronSchedulerTriggerRuntime()],
+            };
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/scheduler-lark-plugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinLarkSchedulerPlugin = createBuiltinLarkSchedulerPlugin;
+const lark_schedule_adapter_js_1 = require("../../scheduler/lark-schedule-adapter.js");
+function createBuiltinLarkSchedulerPlugin(options) {
+    return {
+        manifest: {
+            id: 'builtin.scheduler-lark',
+            kind: 'scheduler',
+            version: '0.1.0',
+            dependsOn: ['builtin.channel-lark'],
+            provides: ['scheduler.delivery.lark'],
+        },
+        capabilities: {
+            schedulers: [
+                {
+                    id: 'scheduler.delivery.lark',
+                    triggerTypes: [],
+                    deliveryTargets: ['lark'],
+                    enabled: true,
+                    displayName: 'Lark Scheduled Delivery',
+                },
+            ],
+        },
+        createRuntime() {
+            return {
+                executors: [
+                    new lark_schedule_adapter_js_1.LarkScheduleAdapter({
+                        store: options.store,
+                        getWorkspaceRouter: options.getWorkspaceRouter,
+                        getChannelRuntime: options.getChannelRuntime,
+                        log: options.log,
+                    }),
+                ],
+            };
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/scheduler-weixin-plugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinWeixinSchedulerPlugin = createBuiltinWeixinSchedulerPlugin;
+const weixin_schedule_adapter_js_1 = require("../../scheduler/weixin-schedule-adapter.js");
+function createBuiltinWeixinSchedulerPlugin(options) {
+    return {
+        manifest: {
+            id: 'builtin.scheduler-weixin',
+            kind: 'scheduler',
+            version: '0.1.0',
+            dependsOn: ['builtin.channel-weixin'],
+            provides: ['scheduler.delivery.weixin'],
+        },
+        capabilities: {
+            schedulers: [
+                {
+                    id: 'scheduler.delivery.weixin',
+                    triggerTypes: [],
+                    deliveryTargets: ['weixin'],
+                    enabled: true,
+                    displayName: 'WeChat Scheduled Delivery',
+                },
+            ],
+        },
+        createRuntime() {
+            return {
+                executors: [
+                    new weixin_schedule_adapter_js_1.WeixinScheduleAdapter({
+                        store: options.store,
+                        getWorkspaceRouter: options.getWorkspaceRouter,
+                        getChannelRuntime: options.getChannelRuntime,
+                        log: options.log,
+                    }),
+                ],
+            };
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/router/workspace-route-config.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePlatformTypes = normalizePlatformTypes;
+exports.isLocalCoreNativeAcpProject = isLocalCoreNativeAcpProject;
+exports.toLocalCoreProjectConfig = toLocalCoreProjectConfig;
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const desktop_js_1 = require("../../../../shared/desktop.js");
+function normalizePlatformTypes(project) {
+    return Array.isArray(project?.platforms)
+        ? project.platforms.map((platform) => (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type)).filter(Boolean)
+        : [];
+}
+function isLocalCoreNativeAcpProject(project) {
+    const agentType = String(project?.agent?.type || '').trim().toLowerCase();
+    return !agentType
+        || agentType === 'acp'
+        || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE;
+}
+function resolveOpencodeModel(project, providers) {
+    const agentType = String(project.agent?.type || '').trim().toLowerCase();
+    const rawModel = String(project.agent?.options?.model || '').trim();
+    const normalizedModel = (0, desktop_js_1.normalizeDesktopAgentModel)(agentType, rawModel);
+    if (agentType !== 'opencode') {
+        return normalizedModel;
+    }
+    const configuredProviderModel = getFirstProviderModelRef(providers);
+    if (configuredProviderModel &&
+        (!rawModel || normalizedModel === desktop_js_1.DEFAULT_DESKTOP_OPENCODE_MODEL)) {
+        return configuredProviderModel;
+    }
+    return normalizedModel;
+}
+function getFirstProviderModelRef(providers) {
+    for (const provider of providers) {
+        const providerId = normalizeOpencodeProviderId(provider.name);
+        const modelId = getProviderDefaultModelId(provider);
+        if (providerId && modelId) {
+            return `${providerId}/${modelId}`;
+        }
+    }
+    return '';
+}
+function getProviderDefaultModelId(provider) {
+    const directModel = String(provider.model || '').trim();
+    if (directModel) {
+        return directModel;
+    }
+    const firstModel = Array.isArray(provider.models)
+        ? provider.models.find((entry) => String(entry?.model || '').trim())
+        : null;
+    return String(firstModel?.model || '').trim();
+}
+function buildOpencodeInlineConfig(model, providers) {
+    const config = {
+        $schema: 'https://opencode.ai/config.json',
+    };
+    const env = {};
+    if (model) {
+        config.model = model;
+    }
+    const providerConfig = {};
+    for (const provider of providers) {
+        const providerId = normalizeOpencodeProviderId(provider.name);
+        if (!providerId) {
+            continue;
+        }
+        const entry = {
+            name: String(provider.name || providerId),
+        };
+        if (shouldUseOpenAiCompatibleProvider(providerId)) {
+            entry.npm = '@ai-sdk/openai-compatible';
+        }
+        const options = {};
+        const baseUrl = String(provider.base_url || '').trim();
+        if (baseUrl) {
+            options.baseURL = baseUrl;
+        }
+        const apiKey = String(provider.api_key || '').trim();
+        if (apiKey) {
+            const envName = opencodeProviderApiKeyEnvName(providerId);
+            env[envName] = apiKey;
+            options.apiKey = `{env:${envName}}`;
+        }
+        if (Object.keys(options).length > 0) {
+            entry.options = options;
+        }
+        const models = buildOpencodeProviderModels(provider);
+        if (Object.keys(models).length > 0) {
+            entry.models = models;
+        }
+        providerConfig[providerId] = entry;
+    }
+    if (Object.keys(providerConfig).length > 0) {
+        config.provider = providerConfig;
+    }
+    return {
+        config,
+        env,
+    };
+}
+function buildOpencodeProviderModels(provider) {
+    const models = {};
+    const addModel = (model, alias) => {
+        const modelId = String(model || '').trim();
+        if (!modelId || models[modelId]) {
+            return;
+        }
+        models[modelId] = {
+            name: String(alias || modelId).trim() || modelId,
+        };
+    };
+    addModel(provider.model);
+    for (const model of Array.isArray(provider.models) ? provider.models : []) {
+        addModel(model?.model, model?.alias);
+    }
+    return models;
+}
+function collectProviderEnv(providers) {
+    const env = {};
+    for (const provider of providers) {
+        if (!provider.env || typeof provider.env !== 'object') {
+            continue;
+        }
+        for (const [key, value] of Object.entries(provider.env)) {
+            const envKey = key.trim();
+            if (envKey) {
+                env[envKey] = String(value ?? '');
+            }
+        }
+    }
+    return env;
+}
+function normalizeOpencodeProviderId(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function opencodeProviderApiKeyEnvName(providerId) {
+    const suffix = providerId.toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    return `AI_WORKSTATION_OPENCODE_${suffix || 'PROVIDER'}_API_KEY`;
+}
+function shouldUseOpenAiCompatibleProvider(providerId) {
+    const builtInNonCompatibleProviders = new Set([
+        'anthropic',
+        'google',
+        'gemini',
+    ]);
+    return !builtInNonCompatibleProviders.has(providerId);
+}
+function resolveBundledClaudeCodeCommand() {
+    const require = (0, node_module_1.createRequire)(__filename);
+    const packageJsonPath = require.resolve(`${desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE}/package.json`);
+    const packageJson = require(packageJsonPath);
+    const binField = packageJson.bin;
+    const relativeBinPath = typeof binField === 'string'
+        ? binField
+        : binField?.['claude-agent-acp'];
+    if (!relativeBinPath) {
+        throw new Error(`Bundled package "${desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE}" does not declare the claude-agent-acp bin.`);
+    }
+    return {
+        command: process.execPath,
+        args: [(0, node_path_1.resolve)((0, node_path_1.dirname)(packageJsonPath), relativeBinPath)],
+    };
+}
+function toLocalCoreProjectConfig(configState, project) {
+    const rawWorkDir = String(project.agent?.options?.work_dir || '.').trim() || '.';
+    const configDir = (0, node_path_1.dirname)(configState.path);
+    const workDir = (0, node_path_1.isAbsolute)(rawWorkDir) ? rawWorkDir : (0, node_path_1.resolve)(configDir, rawWorkDir);
+    const rawArgs = project.agent?.options?.args;
+    const args = Array.isArray(rawArgs)
+        ? rawArgs.map((value) => String(value || '')).filter(Boolean)
+        : [];
+    const rawEnv = project.agent?.options?.env;
+    const env = rawEnv && typeof rawEnv === 'object'
+        ? Object.fromEntries(Object.entries(rawEnv)
+            .filter(([key]) => key)
+            .map(([key, value]) => [key, String(value ?? '')]))
+        : {};
+    const agentType = String(project.agent?.type || '').trim().toLowerCase();
+    const providers = Array.isArray(project.agent?.providers) ? project.agent.providers : [];
+    const model = resolveOpencodeModel(project, providers);
+    const providerEnv = collectProviderEnv(providers);
+    const opencodeInlineConfig = agentType === 'opencode'
+        ? buildOpencodeInlineConfig(model, providers)
+        : null;
+    const inferredOpencodeEnv = agentType === 'opencode'
+        ? {
+            ...(opencodeInlineConfig?.env || {}),
+            OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeInlineConfig?.config || { $schema: 'https://opencode.ai/config.json' }),
+        }
+        : {};
+    const inferredClaudeCodeEnv = agentType === 'claudecode' && model
+        ? {
+            ANTHROPIC_MODEL: model,
+        }
+        : {};
+    const bundledClaudeCode = agentType === 'claudecode'
+        ? resolveBundledClaudeCodeCommand()
+        : null;
+    const inferredCommand = agentType === 'opencode'
+        ? 'opencode'
+        : bundledClaudeCode?.command || '';
+    const command = String(project.agent?.options?.command || inferredCommand).trim();
+    if (!command) {
+        throw new Error(`Workspace "${project.name}" requires [projects.agent.options].command for Local AI Core ACP execution.`);
+    }
+    const defaultArgs = agentType === 'opencode'
+        ? ['acp']
+        : agentType === 'claudecode'
+            ? [...(bundledClaudeCode?.args || [])]
+            : [];
+    return {
+        workspaceId: project.name,
+        agentType,
+        workDir,
+        command,
+        args: args.length > 0 ? args : defaultArgs,
+        env: {
+            ...providerEnv,
+            ...inferredOpencodeEnv,
+            ...inferredClaudeCodeEnv,
+            ...env,
+        },
+        model,
+    };
+}

package/dist-electron/services/local-ai-core/src/router/workspace-router-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });