@kafca/agentdock 0.1.30 → 0.1.33

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePlatformTypes = normalizePlatformTypes;
 exports.isLocalCoreNativeAcpProject = isLocalCoreNativeAcpProject;
 exports.toLocalCoreProjectConfig = toLocalCoreProjectConfig;
-const node_module_1 = require("node:module");
-const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../shared/desktop.js");
+const index_js_1 = require("../agents/index.js");
+const launch_utils_js_1 = require("../agents/shared/launch-utils.js");
 function normalizePlatformTypes(project) {
     return Array.isArray(project?.platforms)
         ? project.platforms.map((platform) => (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type)).filter(Boolean)
@@ -18,348 +18,16 @@ function isLocalCoreNativeAcpProject(project) {
         || agentType === 'acp'
         || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE;
 }
-function resolveAgentModel(project, providers) {
+function resolveAgentModel(project, providers, definition) {
     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 === 'pi') {
-        return rawModel || getFirstProviderModelId(providers);
-    }
-    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 getFirstProviderModelId(providers) {
-    for (const provider of providers) {
-        const modelId = getProviderDefaultModelId(provider);
-        if (modelId) {
-            return modelId;
-        }
-    }
-    return '';
-}
-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 collectPiProviderEnv(providers) {
-    const env = {};
-    for (const provider of providers) {
-        const apiKey = String(provider.api_key || '').trim();
-        const envName = piProviderApiKeyEnvName(provider.name);
-        if (apiKey && envName) {
-            env[envName] = apiKey;
-        }
-    }
-    return env;
-}
-function resolvePiProviderModel(providers, model) {
-    const [explicitProvider, explicitModel] = splitProviderModelRef(model);
-    if (explicitProvider && explicitModel) {
-        return {
-            providerId: normalizePiProviderId(explicitProvider),
-            modelId: explicitModel,
-        };
-    }
-    for (const provider of providers) {
-        const providerId = normalizePiProviderId(provider.name);
-        const modelId = getProviderDefaultModelId(provider);
-        if (providerId && modelId && (!model || model === modelId)) {
-            return { providerId, modelId };
-        }
-    }
-    const fallbackProvider = providers.find((provider) => normalizePiProviderId(provider.name));
-    return {
-        providerId: normalizePiProviderId(fallbackProvider?.name),
-        modelId: model,
-    };
-}
-function splitProviderModelRef(value) {
-    const trimmed = value.trim();
-    const slashIndex = trimmed.indexOf('/');
-    if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
-        return ['', trimmed];
-    }
-    return [trimmed.slice(0, slashIndex), trimmed.slice(slashIndex + 1)];
-}
-function normalizePiProviderId(providerName) {
-    const providerId = normalizeProviderId(providerName);
-    const aliases = {
-        google: 'google',
-        gemini: 'google',
-        kimi: 'kimi-coding',
-        moonshot: 'moonshotai',
-        zhipuai: 'zai',
-    };
-    return aliases[providerId] || providerId;
-}
-function piProviderAgentDir(configState, projectName) {
-    const configDir = (0, node_path_1.dirname)(configState.path);
-    const safeProjectName = String(projectName || 'workspace')
-        .trim()
-        .replace(/[^a-zA-Z0-9._-]+/g, '-')
-        .replace(/^-+|-+$/g, '') || 'workspace';
-    return (0, node_path_1.resolve)(configDir, '.pi-agent', safeProjectName);
-}
-function writeJsonFile(path, value, mode = 0o600) {
-    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode });
-    (0, node_fs_1.chmodSync)(path, mode);
-}
-function writePiProviderRuntimeConfig(configState, project, providers, model) {
-    if (providers.length === 0) {
-        return {};
-    }
-    const { providerId, modelId } = resolvePiProviderModel(providers, model);
-    const agentDir = piProviderAgentDir(configState, project.name);
-    (0, node_fs_1.mkdirSync)(agentDir, { recursive: true, mode: 0o700 });
-    (0, node_fs_1.chmodSync)(agentDir, 0o700);
-    const auth = {};
-    const modelProviders = {};
-    for (const provider of providers) {
-        const id = normalizePiProviderId(provider.name);
-        if (!id) {
-            continue;
-        }
-        const apiKey = String(provider.api_key || '').trim();
-        const baseUrl = String(provider.base_url || '').trim();
-        if (apiKey) {
-            auth[id] = { type: 'api_key', key: apiKey };
-        }
-        if (baseUrl || apiKey) {
-            modelProviders[id] = {
-                name: String(provider.name || id).trim() || id,
-                ...(baseUrl ? { baseUrl } : {}),
-                ...(apiKey ? { apiKey } : {}),
-            };
-        }
-    }
-    writeJsonFile((0, node_path_1.resolve)(agentDir, 'auth.json'), auth);
-    writeJsonFile((0, node_path_1.resolve)(agentDir, 'models.json'), { providers: modelProviders });
-    writeJsonFile((0, node_path_1.resolve)(agentDir, 'settings.json'), {
-        ...(providerId ? { defaultProvider: providerId } : {}),
-        ...(modelId ? { defaultModel: modelId } : {}),
-        quietStartup: true,
-    }, 0o644);
-    return {
-        PI_CODING_AGENT_DIR: agentDir,
-    };
-}
-function normalizeOpencodeProviderId(value) {
-    return String(value || '')
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9._-]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-function normalizeProviderId(value) {
-    return String(value || '')
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-function piProviderApiKeyEnvName(providerName) {
-    const providerId = normalizeProviderId(providerName);
-    const envNames = {
-        anthropic: 'ANTHROPIC_API_KEY',
-        'azure-openai': 'AZURE_OPENAI_API_KEY',
-        'azure-openai-responses': 'AZURE_OPENAI_API_KEY',
-        cerebras: 'CEREBRAS_API_KEY',
-        cloudflare: 'CLOUDFLARE_API_KEY',
-        'cloudflare-ai-gateway': 'CLOUDFLARE_API_KEY',
-        'cloudflare-workers-ai': 'CLOUDFLARE_API_KEY',
-        deepseek: 'DEEPSEEK_API_KEY',
-        fireworks: 'FIREWORKS_API_KEY',
-        gemini: 'GEMINI_API_KEY',
-        google: 'GEMINI_API_KEY',
-        groq: 'GROQ_API_KEY',
-        huggingface: 'HF_TOKEN',
-        kimi: 'KIMI_API_KEY',
-        'kimi-coding': 'KIMI_API_KEY',
-        minimax: 'MINIMAX_API_KEY',
-        'minimax-cn': 'MINIMAX_CN_API_KEY',
-        mistral: 'MISTRAL_API_KEY',
-        moonshot: 'KIMI_API_KEY',
-        openai: 'OPENAI_API_KEY',
-        opencode: 'OPENCODE_API_KEY',
-        'opencode-go': 'OPENCODE_API_KEY',
-        openrouter: 'OPENROUTER_API_KEY',
-        siliconflow: 'SILICONFLOW_API_KEY',
-        vercel: 'AI_GATEWAY_API_KEY',
-        'vercel-ai-gateway': 'AI_GATEWAY_API_KEY',
-        xai: 'XAI_API_KEY',
-        zai: 'ZAI_API_KEY',
-        zhipuai: 'ZAI_API_KEY',
-    };
-    return envNames[providerId] || '';
-}
-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 resolveBundledAcpCommand(packageName, binName) {
-    const require = (0, node_module_1.createRequire)(__filename);
-    const packageJsonPath = resolveBundledPackageJsonPath(packageName);
-    const packageJson = require(packageJsonPath);
-    const binField = packageJson.bin;
-    const relativeBinPath = typeof binField === 'string'
-        ? binField
-        : binField?.[binName];
-    if (!relativeBinPath) {
-        throw new Error(`Bundled package "${packageName}" does not declare the ${binName} bin.`);
-    }
-    return {
-        command: process.execPath,
-        args: [(0, node_path_1.resolve)((0, node_path_1.dirname)(packageJsonPath), relativeBinPath)],
-    };
-}
-function resolveBundledPackageJsonPath(packageName) {
-    const require = (0, node_module_1.createRequire)(__filename);
-    try {
-        return require.resolve(`${packageName}/package.json`);
-    }
-    catch (error) {
-        if (error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
-            throw error;
-        }
-    }
-    for (const basePath of require.resolve.paths(packageName) || []) {
-        const packageJsonPath = (0, node_path_1.resolve)(basePath, ...packageName.split('/'), 'package.json');
-        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
-            return packageJsonPath;
-        }
-    }
-    let current = (0, node_path_1.dirname)(require.resolve(packageName));
-    while (current && current !== (0, node_path_1.dirname)(current)) {
-        const packageJsonPath = (0, node_path_1.resolve)(current, 'package.json');
-        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
-            return packageJsonPath;
-        }
-        current = (0, node_path_1.dirname)(current);
-    }
-    throw new Error(`Bundled package "${packageName}" package.json could not be resolved.`);
-}
-function resolveBundledCodexCommand() {
-    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_CODEX_ACP_PACKAGE, 'codex-acp');
-}
-function resolveBundledClaudeCodeCommand() {
-    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE, 'claude-agent-acp');
-}
-function resolveBundledPiAcpCommand() {
-    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_PI_ACP_PACKAGE, 'pi-acp');
-}
-function resolveBundledPiCommand() {
-    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_PI_CODING_AGENT_PACKAGE, 'pi').args[0];
+    return definition?.resolveModel?.({
+        project,
+        providers,
+        rawModel,
+        normalizedModel,
+    }) || normalizedModel;
 }
 function toLocalCoreProjectConfig(configState, project) {
     const rawWorkDir = String(project.agent?.options?.work_dir || '.').trim() || '.';
@@ -377,63 +45,22 @@ function toLocalCoreProjectConfig(configState, project) {
         : {};
     const agentType = String(project.agent?.type || '').trim().toLowerCase();
     const providers = Array.isArray(project.agent?.providers) ? project.agent.providers : [];
-    const model = resolveAgentModel(project, providers);
-    const providerEnv = collectProviderEnv(providers);
-    const piProviderEnv = agentType === 'pi'
-        ? collectPiProviderEnv(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 bundledPiAcp = agentType === 'pi'
-        ? resolveBundledPiAcpCommand()
-        : null;
-    const bundledPiCommand = agentType === 'pi'
-        ? resolveBundledPiCommand()
-        : '';
-    const piProviderRuntimeEnv = agentType === 'pi'
-        ? writePiProviderRuntimeConfig(configState, project, providers, model)
-        : {};
-    const inferredPiEnv = agentType === 'pi'
-        ? {
-            ...piProviderEnv,
-            ...piProviderRuntimeEnv,
-            PI_ACP_PI_COMMAND: bundledPiCommand,
-        }
-        : {};
-    const bundledCodex = agentType === 'codex'
-        ? resolveBundledCodexCommand()
-        : null;
-    const bundledClaudeCode = agentType === 'claudecode'
-        ? resolveBundledClaudeCodeCommand()
-        : null;
-    const inferredCommand = agentType === 'opencode'
-        ? 'opencode'
-        : bundledPiAcp?.command || bundledCodex?.command || bundledClaudeCode?.command || '';
+    const definition = (0, index_js_1.resolveAgentRuntimeDefinition)(agentType);
+    const model = resolveAgentModel(project, providers, definition);
+    const providerEnv = (0, launch_utils_js_1.collectProviderEnv)(providers);
+    const launchDefaults = definition?.buildLaunchConfig?.({
+        configState,
+        project,
+        agentType,
+        providers,
+        model,
+    }) || {};
+    const inferredCommand = launchDefaults.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 === 'pi'
-            ? [...(bundledPiAcp?.args || [])]
-            : agentType === 'codex'
-                ? [...(bundledCodex?.args || [])]
-                : agentType === 'claudecode'
-                    ? [...(bundledClaudeCode?.args || [])]
-                    : [];
+    const defaultArgs = launchDefaults.args || [];
     return {
         workspaceId: project.name,
         agentType,
@@ -441,9 +68,7 @@ function toLocalCoreProjectConfig(configState, project) {
         command,
         args: args.length > 0 ? args : defaultArgs,
         env: {
-            ...inferredOpencodeEnv,
-            ...inferredClaudeCodeEnv,
-            ...inferredPiEnv,
+            ...(launchDefaults.env || {}),
             ...providerEnv,
             ...env,
         },

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

@@ -6,44 +6,16 @@ const node_path_1 = require("node:path");
 const node_module_1 = require("node:module");
 const node_child_process_1 = require("node:child_process");
 const desktop_js_1 = require("../../../../shared/desktop.js");
-const DISPLAY_NAMES = {
-    pi: 'Pi',
-    opencode: 'OpenCode',
-    codex: 'Codex',
-    claudecode: 'Claude Code',
-    cursor: 'Cursor',
-    gemini: 'Gemini',
-    qoder: 'Qoder',
-    iflow: 'iFlow',
-    [desktop_js_1.LOCALCORE_ACP_AGENT_TYPE]: 'LocalCore ACP',
-};
-const COMMAND_CANDIDATES = {
-    pi: ['pi'],
-    opencode: ['opencode'],
-    codex: ['codex-acp', 'codex'],
-    claudecode: ['claude-agent-acp', 'claude'],
-    cursor: ['cursor-agent', 'cursor'],
-    gemini: ['gemini'],
-    qoder: ['qoder'],
-    iflow: ['iflow'],
-};
-const VERSION_ARGUMENTS = {
-    pi: ['--version'],
-    opencode: ['--version'],
-    codex: ['--version'],
-    claudecode: ['--version'],
-    cursor: ['--version'],
-    gemini: ['--version'],
-    qoder: ['--version'],
-    iflow: ['--version'],
-};
+const index_js_1 = require("../agents/index.js");
 function detectInstalledAgentRuntimes(options = {}) {
     const env = options.env || process.env;
     const configuredCommands = collectConfiguredAgentCommands(options.config);
     const detectedAt = (options.now || new Date()).toISOString();
     const versionTimeoutMs = options.versionTimeoutMs ?? 2500;
     return desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS.map((agentType) => {
-        if (agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {
+        const definition = (0, index_js_1.resolveAgentRuntimeDefinition)(agentType);
+        const detection = definition?.detection;
+        if (detection?.builtin || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {
             return {
                 agentType,
                 runtimeId: agentType,
@@ -64,21 +36,13 @@ function detectInstalledAgentRuntimes(options = {}) {
                 ? installedRuntime(agentType, resolved, 'config', detectedAt, env, versionTimeoutMs)
                 : missingRuntime(agentType, detectedAt, `Configured command not found: ${configured}`);
         }
-        if (agentType === 'pi' || agentType === 'codex' || agentType === 'claudecode') {
-            const bundled = agentType === 'pi'
-                ? resolveBundledAcpPackage(options.requireFrom, desktop_js_1.DESKTOP_PI_CODING_AGENT_PACKAGE, ['dist/cli.js'])
-                : agentType === 'codex'
-                    ? resolveBundledAcpPackage(options.requireFrom, desktop_js_1.DESKTOP_CODEX_ACP_PACKAGE, ['bin/codex-acp.js'])
-                    : resolveBundledAcpPackage(options.requireFrom, desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE, [
-                        'dist/cli.js',
-                        'bin/claude-agent-acp.js',
-                        'cli.js',
-                    ]);
+        for (const bundledRuntime of detection?.bundledRuntimes || []) {
+            const bundled = resolveBundledAcpPackage(options.requireFrom, bundledRuntime.packageName, bundledRuntime.candidates);
             if (bundled) {
                 return installedRuntime(agentType, bundled, 'bundled', detectedAt, env, versionTimeoutMs);
             }
         }
-        for (const command of COMMAND_CANDIDATES[agentType] || [agentType]) {
+        for (const command of detection?.commandCandidates || [agentType]) {
             const resolved = resolveCommand(command, env);
             if (resolved) {
                 return installedRuntime(agentType, resolved, 'path', detectedAt, env, versionTimeoutMs);
@@ -143,7 +107,7 @@ function missingRuntime(agentType, detectedAt, error) {
     };
 }
 function displayName(agentType) {
-    return DISPLAY_NAMES[agentType] || agentType;
+    return (0, index_js_1.resolveAgentRuntimeDefinition)(agentType)?.displayName || agentType;
 }
 function collectConfiguredAgentCommands(config) {
     const commands = new Map();
@@ -194,7 +158,7 @@ function isExecutableFile(path) {
     }
 }
 function detectRuntimeVersion(agentType, command, env, timeoutMs) {
-    const args = VERSION_ARGUMENTS[agentType];
+    const args = (0, index_js_1.resolveAgentRuntimeDefinition)(agentType)?.detection?.versionArgs;
     if (!args || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {
         return {};
     }

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

@@ -4,6 +4,7 @@ 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;
@@ -195,7 +196,10 @@ class LocalCoreController extends node_events_1.EventEmitter {
     }
     resolveScheduledJobCreateInput(input) {
         if (input.platform && input.route) {
-            return input;
+            return {
+                ...input,
+                route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route),
+            };
         }
         const threadId = String(input.threadId || input.route?.threadId || '').trim();
         if (threadId) {
@@ -208,7 +212,6 @@ class LocalCoreController extends node_events_1.EventEmitter {
                         type: 'channel.chat',
                         channelId: binding.chat_id,
                         participantId: binding.platform_user_id,
-                        threadId,
                     },
                 };
             }
@@ -219,12 +222,14 @@ class LocalCoreController extends node_events_1.EventEmitter {
             route: {
                 type: 'local.thread',
                 channelId: input.workspaceId,
-                ...(threadId ? { threadId } : {}),
             },
         };
     }
     async updateScheduledJob(jobId, input) {
-        return this.scheduler.updateJob(jobId, input);
+        return this.scheduler.updateJob(jobId, {
+            ...input,
+            ...(input.route ? { route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) } : {}),
+        });
     }
     async deleteScheduledJob(jobId) {
         return this.scheduler.deleteJob(jobId);

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

@@ -42,6 +42,8 @@ const DEFAULT_CONFIG = `# Managed by Local AI Core
 `;
 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;
@@ -112,7 +114,13 @@ class FileBackedLocalCoreRuntimeState {
         return this.settings.knowledge;
     }
     getLogs(limit = 200) {
-        return this.logs.slice(-Math.max(limit, 1));
+        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);
     }
     pushLog(message) {
         if (!message) {
@@ -273,6 +281,59 @@ 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);
 }