@kafca/agentdock 0.1.14 → 0.1.16

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

@@ -45,21 +45,28 @@ async function handleAdd(flags, env, io, json) {
     const description = getRequiredFlag(flags, 'desc');
     const executionMode = getExecutionMode(flags);
     const context = resolveContext(flags, env);
-    if (!context.workspaceId || !context.threadId) {
-        throw new Error('scheduler add requires a current workspace/thread context.');
-    }
-    if (context.platform !== 'lark' || !['channel.chat', 'lark_chat'].includes(context.routeType) || !context.chatId || !context.platformUserId) {
-        throw new Error('scheduler add requires a bound Lark route. Missing LOCAL_AI_CHAT_ID or LOCAL_AI_PLATFORM_USER_ID.');
+    if (!context.workspaceId) {
+        throw new Error('scheduler add requires a workspace context. Set LOCAL_AI_WORKSPACE_ID or pass --workspace.');
     }
+    const isLarkRoute = context.platform === 'lark'
+        && ['channel.chat', 'lark_chat'].includes(context.routeType)
+        && context.chatId
+        && context.platformUserId;
     const job = await request(context.baseUrl, 'POST', '/scheduler/jobs', {
         workspaceId: context.workspaceId,
-        platform: 'lark',
-        route: {
-            type: 'channel.chat',
-            channelId: context.chatId,
-            participantId: context.platformUserId,
-            threadId: context.threadId,
-        },
+        platform: isLarkRoute ? 'lark' : 'local',
+        route: isLarkRoute
+            ? {
+                type: 'channel.chat',
+                channelId: context.chatId,
+                participantId: context.platformUserId,
+                ...(context.threadId ? { threadId: context.threadId } : {}),
+            }
+            : {
+                type: 'local.thread',
+                channelId: context.workspaceId,
+                ...(context.threadId ? { threadId: context.threadId } : {}),
+            },
         executionMode,
         triggerType: 'cron',
         cronExpr,

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

@@ -15,6 +15,7 @@ const knowledge_ai_vector_plugin_js_1 = require("../plugins/builtin/knowledge-ai
 const knowledge_noop_plugin_js_1 = require("../plugins/builtin/knowledge-noop-plugin.js");
 const scheduler_cron_plugin_js_1 = require("../plugins/builtin/scheduler-cron-plugin.js");
 const scheduler_lark_plugin_js_1 = require("../plugins/builtin/scheduler-lark-plugin.js");
+const scheduler_local_plugin_js_1 = require("../plugins/builtin/scheduler-local-plugin.js");
 const scheduler_weixin_plugin_js_1 = require("../plugins/builtin/scheduler-weixin-plugin.js");
 const workspace_router_js_1 = require("../router/workspace-router.js");
 const local_core_runtime_state_js_1 = require("../runtime/local-core-runtime-state.js");
@@ -187,6 +188,10 @@ function bootstrapLocalCoreRuntime(options) {
             setConfig: (input) => state.updateKnowledgeConfig(input),
         });
     const schedulerPlugins = [
+        (0, scheduler_local_plugin_js_1.createBuiltinLocalSchedulerPlugin)({
+            store,
+            getWorkspaceRouter: () => workspaceRouter,
+        }),
         (0, scheduler_lark_plugin_js_1.createBuiltinLarkSchedulerPlugin)({
             store,
             getWorkspaceRouter: () => workspaceRouter,

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinLocalSchedulerPlugin = createBuiltinLocalSchedulerPlugin;
+const local_schedule_adapter_js_1 = require("../../scheduler/local-schedule-adapter.js");
+function createBuiltinLocalSchedulerPlugin(options) {
+    return {
+        manifest: {
+            id: 'builtin.scheduler-local',
+            kind: 'scheduler',
+            version: '0.1.0',
+            provides: ['scheduler.delivery.local'],
+        },
+        capabilities: {
+            schedulers: [
+                {
+                    id: 'scheduler.delivery.local',
+                    triggerTypes: [],
+                    deliveryTargets: ['local'],
+                    enabled: true,
+                    displayName: 'Local Scheduled Execution',
+                },
+            ],
+        },
+        createRuntime() {
+            return {
+                executors: [
+                    new local_schedule_adapter_js_1.LocalScheduleAdapter({
+                        store: options.store,
+                        getWorkspaceRouter: options.getWorkspaceRouter,
+                    }),
+                ],
+            };
+        },
+    };
+}

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkspaceRouter = exports.encodeThreadId = exports.decodeThreadId = void 0;
 exports.createWorkspaceRouter = createWorkspaceRouter;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
 const local_core_acp_backend_js_1 = require("../acp/local-core-acp-backend.js");
 const workspace_thread_id_js_1 = require("../thread/workspace-thread-id.js");
+const command_risk_js_1 = require("../security/command-risk.js");
 const workspace_route_config_js_1 = require("./workspace-route-config.js");
 var workspace_thread_id_js_2 = require("../thread/workspace-thread-id.js");
 Object.defineProperty(exports, "decodeThreadId", { enumerable: true, get: function () { return workspace_thread_id_js_2.decodeThreadId; } });
@@ -79,6 +82,95 @@ class WorkspaceRouter {
         }
         return [...workspaceMap.values()].sort((a, b) => a.name.localeCompare(b.name));
     }
+    async listWorkspaceRegistry() {
+        await this.syncConfiguredWorkspaces();
+        return this.store.listWorkspaceRegistry();
+    }
+    async getWorkspaceRegistryEntry(workspaceId) {
+        await this.syncConfiguredWorkspaces();
+        const workspace = this.store.getWorkspaceRegistryEntry(workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace not found: ${workspaceId}`);
+        }
+        return workspace;
+    }
+    async createWorkspaceRegistryEntry(input) {
+        return this.store.upsertWorkspaceRegistryEntry({
+            ...input,
+            deviceId: 'local',
+            git: detectGitSummary(input.path),
+            health: workspaceHealth(input.path),
+        });
+    }
+    async updateWorkspaceRegistryEntry(workspaceId, input) {
+        const next = this.store.updateWorkspaceRegistryEntry(workspaceId, input);
+        return this.store.upsertWorkspaceRegistryEntry({
+            workspaceId: next.workspaceId,
+            displayName: next.displayName,
+            path: next.path,
+            deviceId: next.deviceId,
+            defaultRuntimeId: next.defaultRuntimeId,
+            git: detectGitSummary(next.path),
+            health: workspaceHealth(next.path),
+            metadata: next.metadata,
+        });
+    }
+    async deleteWorkspaceRegistryEntry(workspaceId) {
+        return this.store.deleteWorkspaceRegistryEntry(workspaceId);
+    }
+    listAgentTasks(query = {}) {
+        return this.store.listAgentTasks(query);
+    }
+    getAgentTask(taskId) {
+        const task = this.store.getAgentTask(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        return task;
+    }
+    createAgentTask(input) {
+        return this.store.createAgentTask({ ...input, deviceId: 'local' });
+    }
+    updateAgentTask(taskId, input) {
+        return this.store.updateAgentTask(taskId, input);
+    }
+    getWorkspaceSecuritySettings(workspaceId) {
+        return this.store.getWorkspaceSecuritySettings(workspaceId);
+    }
+    updateWorkspaceSecuritySettings(workspaceId, input) {
+        return this.store.updateWorkspaceSecuritySettings(workspaceId, input);
+    }
+    classifyCommand(command, workspaceId) {
+        const classification = (0, command_risk_js_1.classifyCommandRisk)(command);
+        this.store.createAuditEvent({
+            type: 'command.classified',
+            workspaceId,
+            actor: 'local',
+            summary: `Command classified as ${classification.riskLevel}.`,
+            riskLevel: classification.riskLevel,
+            metadata: { classification: { ...classification } },
+        });
+        return classification;
+    }
+    listApprovalRequests(query = {}) {
+        return this.store.listApprovalRequests(query);
+    }
+    getApprovalRequest(approvalId) {
+        const approval = this.store.getApprovalRequest(approvalId);
+        if (!approval) {
+            throw new Error(`Approval not found: ${approvalId}`);
+        }
+        return approval;
+    }
+    createApprovalRequest(input) {
+        return this.store.createApprovalRequest(input);
+    }
+    resolveApprovalRequest(approvalId, input) {
+        return this.store.resolveApprovalRequest(approvalId, input);
+    }
+    listAuditEvents(query = {}) {
+        return this.store.listAuditEvents(query);
+    }
     async listThreads(workspaceId) {
         await this.getWorkspaceRoute(workspaceId);
         return this.localCoreAcp.listThreads(workspaceId);
@@ -348,6 +440,29 @@ class WorkspaceRouter {
         const projects = Array.isArray(configState.parsed?.projects) ? configState.parsed.projects : [];
         return projects.filter((project) => this.resolveProjectRoute(configState, project));
     }
+    async syncConfiguredWorkspaces() {
+        const config = await this.options.readConfigState();
+        const projects = Array.isArray(config.parsed?.projects) ? config.parsed.projects : [];
+        for (const project of projects) {
+            const route = this.resolveProjectRoute(config, project);
+            if (!route) {
+                continue;
+            }
+            const path = inferWorkspacePath(project);
+            this.store.upsertWorkspaceRegistryEntry({
+                workspaceId: project.name,
+                displayName: project.name,
+                path,
+                deviceId: 'local',
+                defaultRuntimeId: route.agentType,
+                git: detectGitSummary(path),
+                health: workspaceHealth(path),
+                metadata: {
+                    platforms: (0, workspace_route_config_js_1.normalizePlatformTypes)(project),
+                },
+            });
+        }
+    }
     resolveProjectRoute(configState, project) {
         for (const runtime of this.options.getAgentRuntimes?.() || []) {
             if (!runtime.matchesProject(project)) {
@@ -387,3 +502,85 @@ exports.WorkspaceRouter = WorkspaceRouter;
 function createWorkspaceRouter(options) {
     return new WorkspaceRouter(options);
 }
+function inferWorkspacePath(project) {
+    const options = project.agent?.options || {};
+    for (const key of ['cwd', 'path', 'workspacePath', 'root']) {
+        const value = options[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return '';
+}
+function workspaceHealth(path) {
+    if (!path) {
+        return {
+            status: 'warning',
+            summary: 'Workspace path is not configured.',
+            issues: [{
+                    code: 'workspace_path_missing',
+                    severity: 'warning',
+                    message: 'Workspace path is not configured.',
+                    help: 'Set a workspace path in the project agent options.',
+                }],
+            checkedAt: new Date().toISOString(),
+        };
+    }
+    if (!(0, node_fs_1.existsSync)(path)) {
+        return {
+            status: 'error',
+            summary: 'Workspace path does not exist.',
+            issues: [{
+                    code: 'workspace_path_not_found',
+                    severity: 'error',
+                    message: `Workspace path does not exist: ${path}`,
+                    help: 'Update the workspace path or restore the missing directory.',
+                }],
+            checkedAt: new Date().toISOString(),
+        };
+    }
+    return {
+        status: 'healthy',
+        summary: 'Workspace is available.',
+        issues: [],
+        checkedAt: new Date().toISOString(),
+    };
+}
+function detectGitSummary(path) {
+    if (!path || !(0, node_fs_1.existsSync)(path)) {
+        return { isRepo: false };
+    }
+    try {
+        const isRepo = git(path, ['rev-parse', '--is-inside-work-tree']) === 'true';
+        if (!isRepo) {
+            return { isRepo: false };
+        }
+        const branch = git(path, ['branch', '--show-current']) || undefined;
+        const remote = git(path, ['config', '--get', 'remote.origin.url']) || undefined;
+        const status = git(path, ['status', '--porcelain']);
+        const sha = git(path, ['rev-parse', '--short', 'HEAD']) || '';
+        const message = git(path, ['log', '-1', '--pretty=%s']) || '';
+        const committedAt = git(path, ['log', '-1', '--pretty=%cI']) || undefined;
+        return {
+            isRepo: true,
+            branch,
+            remote,
+            dirty: Boolean(status),
+            lastCommit: sha ? { sha, message, committedAt } : undefined,
+        };
+    }
+    catch (error) {
+        return {
+            isRepo: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function git(cwd, args) {
+    return (0, node_child_process_1.execFileSync)('git', args, {
+        cwd,
+        encoding: 'utf8',
+        timeout: 1500,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+}

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

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectInstalledAgentRuntimes = detectInstalledAgentRuntimes;
+const node_fs_1 = require("node:fs");
+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 = {
+    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 = {
+    opencode: ['opencode'],
+    codex: ['codex'],
+    claudecode: ['claude-agent-acp'],
+    cursor: ['cursor-agent', 'cursor'],
+    gemini: ['gemini'],
+    qoder: ['qoder'],
+    iflow: ['iflow'],
+};
+const VERSION_ARGUMENTS = {
+    opencode: ['--version'],
+    codex: ['--version'],
+    claudecode: ['--version'],
+    cursor: ['--version'],
+    gemini: ['--version'],
+    qoder: ['--version'],
+    iflow: ['--version'],
+};
+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) {
+            return {
+                agentType,
+                runtimeId: agentType,
+                displayName: displayName(agentType),
+                status: 'installed',
+                installed: true,
+                detectedAt,
+                summary: `${displayName(agentType)} is built in.`,
+                issues: [],
+                recommendedActions: [],
+                source: 'builtin',
+            };
+        }
+        const configured = configuredCommands.get(agentType);
+        if (configured) {
+            const resolved = resolveCommand(configured, env);
+            return resolved
+                ? installedRuntime(agentType, resolved, 'config', detectedAt, env, versionTimeoutMs)
+                : missingRuntime(agentType, detectedAt, `Configured command not found: ${configured}`);
+        }
+        if (agentType === 'claudecode') {
+            const bundled = resolveBundledClaudeAgentAcp(options.requireFrom);
+            if (bundled) {
+                return installedRuntime(agentType, bundled, 'bundled', detectedAt, env, versionTimeoutMs);
+            }
+        }
+        for (const command of COMMAND_CANDIDATES[agentType] || [agentType]) {
+            const resolved = resolveCommand(command, env);
+            if (resolved) {
+                return installedRuntime(agentType, resolved, 'path', detectedAt, env, versionTimeoutMs);
+            }
+        }
+        return missingRuntime(agentType, detectedAt);
+    });
+}
+function installedRuntime(agentType, command, source, detectedAt, env, versionTimeoutMs) {
+    const versionResult = detectRuntimeVersion(agentType, command, env, versionTimeoutMs);
+    const issues = versionResult.issue ? [versionResult.issue] : [];
+    return {
+        agentType,
+        runtimeId: agentType,
+        displayName: displayName(agentType),
+        status: 'installed',
+        installed: true,
+        command,
+        binaryPath: command,
+        version: versionResult.version,
+        detectedAt,
+        summary: versionResult.version
+            ? `${displayName(agentType)} ${versionResult.version} is installed.`
+            : `${displayName(agentType)} is installed.`,
+        details: issues[0]?.message,
+        issues,
+        recommendedActions: [],
+        source,
+    };
+}
+function missingRuntime(agentType, detectedAt, error) {
+    const name = displayName(agentType);
+    return {
+        agentType,
+        runtimeId: agentType,
+        displayName: name,
+        status: error ? 'error' : 'not_installed',
+        installed: false,
+        detectedAt,
+        summary: error || `${name} was not found on PATH or in project configuration.`,
+        details: error,
+        issues: [
+            {
+                code: error ? 'configured_command_not_found' : 'runtime_not_found',
+                severity: error ? 'error' : 'info',
+                message: error || `${name} is not installed or is not available on PATH.`,
+                help: error
+                    ? 'Update the project runtime command or make the configured binary executable.'
+                    : 'Install the runtime manually, then refresh detection.',
+            },
+        ],
+        recommendedActions: [
+            {
+                label: error ? 'Fix configured command' : `Install ${name}`,
+                description: error
+                    ? 'Check the workspace agent command path in configuration.'
+                    : `Install ${name} manually and make sure its command is available on PATH.`,
+            },
+        ],
+        source: 'path',
+        error,
+    };
+}
+function displayName(agentType) {
+    return DISPLAY_NAMES[agentType] || agentType;
+}
+function collectConfiguredAgentCommands(config) {
+    const commands = new Map();
+    for (const project of Array.isArray(config?.projects) ? config.projects : []) {
+        const agentType = String(project?.agent?.type || '').trim().toLowerCase();
+        const command = String(project?.agent?.options?.command || '').trim();
+        if (agentType && command && !commands.has(agentType)) {
+            commands.set(agentType, command);
+        }
+    }
+    return commands;
+}
+function resolveCommand(command, env) {
+    const normalized = command.trim();
+    if (!normalized) {
+        return null;
+    }
+    if ((0, node_path_1.isAbsolute)(normalized) || normalized.includes('/') || normalized.includes('\\')) {
+        return isExecutableFile(normalized) ? normalized : null;
+    }
+    for (const dir of String(env.PATH || '').split(node_path_1.delimiter).filter(Boolean)) {
+        for (const candidate of commandCandidates(normalized, env)) {
+            const fullPath = (0, node_path_1.join)(dir, candidate);
+            if (isExecutableFile(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}
+function commandCandidates(command, env) {
+    if (process.platform !== 'win32' || /\.[a-z0-9]+$/i.test(command)) {
+        return [command];
+    }
+    const extensions = String(env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map((ext) => ext.trim())
+        .filter(Boolean);
+    return [command, ...extensions.map((ext) => `${command}${ext}`)];
+}
+function isExecutableFile(path) {
+    try {
+        (0, node_fs_1.accessSync)(path, node_fs_1.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function detectRuntimeVersion(agentType, command, env, timeoutMs) {
+    const args = VERSION_ARGUMENTS[agentType];
+    if (!args || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {
+        return {};
+    }
+    try {
+        const output = (0, node_child_process_1.execFileSync)(command, args, {
+            env,
+            timeout: timeoutMs,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return { version: parseVersionOutput(output) };
+    }
+    catch (err) {
+        const timedOut = err?.code === 'ETIMEDOUT' || err?.signal === 'SIGTERM';
+        return {
+            issue: {
+                code: timedOut ? 'version_detection_timeout' : 'version_detection_failed',
+                severity: 'warning',
+                message: timedOut
+                    ? `${displayName(agentType)} was found, but version detection timed out.`
+                    : `${displayName(agentType)} was found, but its version could not be detected.`,
+                help: 'Installation detection remains valid because the executable was resolved.',
+            },
+        };
+    }
+}
+function parseVersionOutput(output) {
+    const text = output.trim().split(/\r?\n/).find(Boolean) || '';
+    const match = text.match(/\d+(?:\.\d+)+(?:[-+._a-zA-Z0-9]*)?/);
+    return match?.[0] || text || undefined;
+}
+function resolveBundledClaudeAgentAcp(requireFrom) {
+    try {
+        const require = (0, node_module_1.createRequire)(requireFrom || (0, node_path_1.join)(process.cwd(), 'package.json'));
+        const packageJsonPath = require.resolve(`${desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE}/package.json`);
+        const packageDir = (0, node_path_1.dirname)(packageJsonPath);
+        for (const candidate of [
+            (0, node_path_1.join)(packageDir, 'dist', 'cli.js'),
+            (0, node_path_1.join)(packageDir, 'bin', 'claude-agent-acp.js'),
+            (0, node_path_1.join)(packageDir, 'cli.js'),
+        ]) {
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                return candidate;
+            }
+        }
+        return packageJsonPath;
+    }
+    catch {
+        return null;
+    }
+}

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 runtime_detection_service_js_1 = require("./runtime-detection-service.js");
 class LocalCoreController extends node_events_1.EventEmitter {
     userDataPath;
     state;
@@ -14,6 +15,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
     scheduler;
     kernel;
     runtime;
+    runtimeDetection;
     busUnsubscribers = [];
     constructor(userDataPath, runtime) {
         super();
@@ -30,6 +32,12 @@ class LocalCoreController extends node_events_1.EventEmitter {
         this.channelRuntime = this.runtime.channelRuntime;
         this.weixinChannelRuntime = this.runtime.weixinChannelRuntime;
         this.scheduler = this.runtime.scheduler;
+        this.runtimeDetection = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => (await this.readConfigFile()).parsed,
+            log: (message) => this.handleLog(message),
+            emit: (event) => this.handleRuntimeDetectionEvent(event),
+        });
         this.busUnsubscribers.push(this.kernel.context.bus.on('platform.bridge.updated', (event) => {
             this.emit('bridge', event);
         }), this.kernel.context.bus.on('scheduler.job.updated', (job) => {
@@ -43,6 +51,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async init() {
         await this.runtime.start();
         await this.emitRuntime();
+        void this.runtimeDetection.refreshOnStartup();
     }
     async close() {
         for (const unsubscribe of this.busUnsubscribers) {
@@ -122,6 +131,57 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async listWorkspaces() {
         return this.workspaceRouter.listWorkspaces();
     }
+    async listWorkspaceRegistry() {
+        return this.workspaceRouter.listWorkspaceRegistry();
+    }
+    async getWorkspaceRegistryEntry(workspaceId) {
+        return this.workspaceRouter.getWorkspaceRegistryEntry(workspaceId);
+    }
+    async createWorkspaceRegistryEntry(input) {
+        return this.workspaceRouter.createWorkspaceRegistryEntry(input);
+    }
+    async updateWorkspaceRegistryEntry(workspaceId, input) {
+        return this.workspaceRouter.updateWorkspaceRegistryEntry(workspaceId, input);
+    }
+    async deleteWorkspaceRegistryEntry(workspaceId) {
+        return this.workspaceRouter.deleteWorkspaceRegistryEntry(workspaceId);
+    }
+    async listAgentTasks(query = {}) {
+        return this.workspaceRouter.listAgentTasks(query);
+    }
+    async getAgentTask(taskId) {
+        return this.workspaceRouter.getAgentTask(taskId);
+    }
+    async createAgentTask(input) {
+        return this.workspaceRouter.createAgentTask(input);
+    }
+    async updateAgentTask(taskId, input) {
+        return this.workspaceRouter.updateAgentTask(taskId, input);
+    }
+    async getWorkspaceSecuritySettings(workspaceId) {
+        return this.workspaceRouter.getWorkspaceSecuritySettings(workspaceId);
+    }
+    async updateWorkspaceSecuritySettings(workspaceId, input) {
+        return this.workspaceRouter.updateWorkspaceSecuritySettings(workspaceId, input);
+    }
+    async classifyCommand(command, workspaceId) {
+        return this.workspaceRouter.classifyCommand(command, workspaceId);
+    }
+    async listApprovalRequests(query = {}) {
+        return this.workspaceRouter.listApprovalRequests(query);
+    }
+    async getApprovalRequest(approvalId) {
+        return this.workspaceRouter.getApprovalRequest(approvalId);
+    }
+    async createApprovalRequest(input) {
+        return this.workspaceRouter.createApprovalRequest(input);
+    }
+    async resolveApprovalRequest(approvalId, input) {
+        return this.workspaceRouter.resolveApprovalRequest(approvalId, input);
+    }
+    async listAuditEvents(query = {}) {
+        return this.workspaceRouter.listAuditEvents(query);
+    }
     async listScheduledJobs(workspaceId) {
         return this.scheduler.listJobs(workspaceId);
     }
@@ -228,12 +288,24 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async getCapabilitySnapshot() {
         return this.kernel.getCapabilitySnapshot().snapshot;
     }
+    async listInstalledAgentRuntimes() {
+        return this.runtimeDetection.list();
+    }
+    async refreshInstalledAgentRuntimes(runtimeId) {
+        return this.runtimeDetection.refresh(runtimeId);
+    }
+    isRuntimeDetectionRunning(runtimeId) {
+        return this.runtimeDetection.isChecking(runtimeId);
+    }
     async getPluginDiagnostics() {
         return this.kernel.diagnostics.snapshot();
     }
     async probeWorkspaceStreaming(workspaceId) {
         return this.workspaceRouter.probeWorkspaceStreaming(workspaceId);
     }
+    handleRuntimeDetectionEvent(event) {
+        this.emit('runtime-detection', event);
+    }
     async listChannelGatewayStatuses(platform) {
         if (!platform) {
             const [larkStatuses, weixinStatuses] = await Promise.all([