@kafca/agentdock 0.1.14 → 0.1.15

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeDetectionService = void 0;
+const desktop_js_1 = require("../../../../shared/desktop.js");
+const agent_runtime_detector_js_1 = require("./agent-runtime-detector.js");
+const runtime_detection_store_js_1 = require("./runtime-detection-store.js");
+class RuntimeDetectionService {
+    options;
+    store;
+    detect;
+    refreshPromise = null;
+    checkingRuntimeIds = new Set();
+    constructor(options) {
+        this.options = options;
+        this.store = new runtime_detection_store_js_1.RuntimeDetectionStore(options.userDataPath);
+        this.detect = options.detect || agent_runtime_detector_js_1.detectInstalledAgentRuntimes;
+    }
+    list(runtimeId) {
+        const cached = this.store.read() || this.createUnknownResults();
+        return this.filter(cached, runtimeId);
+    }
+    isChecking(runtimeId) {
+        if (!runtimeId) {
+            return this.checkingRuntimeIds.size > 0;
+        }
+        return this.checkingRuntimeIds.has(runtimeId);
+    }
+    async refresh(runtimeId) {
+        if (this.refreshPromise) {
+            const runtimes = await this.refreshPromise;
+            return this.filter(runtimes, runtimeId);
+        }
+        this.refreshPromise = this.runRefresh(runtimeId).finally(() => {
+            this.refreshPromise = null;
+        });
+        const runtimes = await this.refreshPromise;
+        return this.filter(runtimes, runtimeId);
+    }
+    async refreshOnStartup() {
+        try {
+            await this.refresh();
+        }
+        catch (err) {
+            this.options.log?.(`Startup runtime detection failed: ${err?.message || String(err)}`);
+        }
+    }
+    async runRefresh(runtimeId) {
+        const previous = this.store.read() || [];
+        const startedAt = new Date().toISOString();
+        this.markChecking(runtimeId);
+        this.emit({ type: 'runtime.detect.started', runtimeId, detectedAt: startedAt });
+        this.options.log?.(runtimeId
+            ? `Started runtime detection for ${runtimeId}.`
+            : 'Started runtime detection for all runtimes.');
+        try {
+            const config = await this.options.readConfig();
+            const detected = this.detect({ config });
+            this.store.write(detected);
+            const completedAt = new Date().toISOString();
+            this.emit({ type: 'runtime.detect.completed', runtimeId, detectedAt: completedAt, runtimes: this.filter(detected, runtimeId) });
+            for (const runtime of changedRuntimes(previous, detected)) {
+                this.emit({ type: 'runtime.status.changed', runtime });
+            }
+            this.options.log?.(runtimeId
+                ? `Completed runtime detection for ${runtimeId}.`
+                : 'Completed runtime detection for all runtimes.');
+            return detected;
+        }
+        catch (err) {
+            const message = err?.message || String(err);
+            this.emit({ type: 'runtime.detect.failed', runtimeId, detectedAt: new Date().toISOString(), error: message });
+            this.options.log?.(`Runtime detection failed: ${message}`);
+            throw err;
+        }
+        finally {
+            this.unmarkChecking();
+        }
+    }
+    createUnknownResults() {
+        const detectedAt = new Date(0).toISOString();
+        return desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS.map((agentType) => ({
+            agentType,
+            runtimeId: agentType,
+            displayName: displayName(agentType),
+            status: agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE ? 'installed' : 'unknown',
+            installed: agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+            detectedAt,
+            summary: agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE
+                ? `${displayName(agentType)} is built in.`
+                : `${displayName(agentType)} has not been checked yet.`,
+            issues: [],
+            recommendedActions: agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE
+                ? []
+                : [{ label: 'Run detection', description: 'Refresh runtime detection to check this machine.' }],
+            source: agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE ? 'builtin' : 'path',
+        }));
+    }
+    filter(runtimes, runtimeId) {
+        if (!runtimeId) {
+            return runtimes;
+        }
+        return runtimes.filter((runtime) => runtime.runtimeId === runtimeId || runtime.agentType === runtimeId);
+    }
+    markChecking(runtimeId) {
+        this.checkingRuntimeIds = new Set(runtimeId ? [runtimeId] : desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS);
+    }
+    unmarkChecking() {
+        this.checkingRuntimeIds.clear();
+    }
+    emit(event) {
+        this.options.emit?.(event);
+    }
+}
+exports.RuntimeDetectionService = RuntimeDetectionService;
+function changedRuntimes(previous, next) {
+    const previousById = new Map(previous.map((runtime) => [runtime.runtimeId, runtime]));
+    return next.filter((runtime) => {
+        const before = previousById.get(runtime.runtimeId);
+        return !before
+            || before.status !== runtime.status
+            || before.version !== runtime.version
+            || before.binaryPath !== runtime.binaryPath
+            || before.error !== runtime.error;
+    });
+}
+function displayName(agentType) {
+    const 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',
+    };
+    return names[agentType] || agentType;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeDetectionStore = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+class RuntimeDetectionStore {
+    path;
+    constructor(userDataPath) {
+        this.path = (0, node_path_1.join)(userDataPath, 'runtime', 'runtime-detection.json');
+    }
+    read() {
+        if (!(0, node_fs_1.existsSync)(this.path)) {
+            return null;
+        }
+        try {
+            const payload = JSON.parse((0, node_fs_1.readFileSync)(this.path, 'utf8'));
+            if (!Array.isArray(payload.runtimes)) {
+                return null;
+            }
+            return payload.runtimes.filter(isRuntimeDetectionResult);
+        }
+        catch {
+            return null;
+        }
+    }
+    write(runtimes) {
+        const payload = {
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            runtimes,
+        };
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.path), { recursive: true });
+        (0, node_fs_1.writeFileSync)(this.path, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    }
+}
+exports.RuntimeDetectionStore = RuntimeDetectionStore;
+function isRuntimeDetectionResult(value) {
+    const runtime = value;
+    return typeof runtime?.agentType === 'string'
+        && typeof runtime.runtimeId === 'string'
+        && typeof runtime.displayName === 'string'
+        && typeof runtime.status === 'string'
+        && typeof runtime.detectedAt === 'string'
+        && Array.isArray(runtime.issues)
+        && Array.isArray(runtime.recommendedActions);
+}

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

@@ -67,6 +67,9 @@ class LocalAiCoreServer {
         this.bindings.on('scheduler-run', (run) => {
             this.broadcast({ type: 'scheduler.run.updated', run });
         });
+        this.bindings.on('runtime-detection', (event) => {
+            this.broadcast(event);
+        });
     }
     async start() {
         await new Promise((resolve, reject) => {
@@ -131,6 +134,36 @@ class LocalAiCoreServer {
                 json(res, 200, this.bindings.getLogs(limit));
                 return;
             }
+            if (req.method === 'GET' && path === '/api/local/v1/runtime/agent-runtimes') {
+                json(res, 200, await this.runtimeDetectionResponse());
+                return;
+            }
+            if (req.method === 'GET' && path === '/api/local/v1/runtimes') {
+                json(res, 200, await this.runtimeDetectionResponse());
+                return;
+            }
+            if (req.method === 'GET' && path.startsWith('/api/local/v1/runtimes/')) {
+                const runtimeId = decodeURIComponent(path.slice('/api/local/v1/runtimes/'.length));
+                const runtimes = await this.bindings.listInstalledAgentRuntimes();
+                const runtime = runtimes.find((entry) => entry.runtimeId === runtimeId || entry.agentType === runtimeId);
+                if (!runtime) {
+                    json(res, 404, null, false, 'Runtime not found');
+                    return;
+                }
+                json(res, 200, runtime);
+                return;
+            }
+            if (req.method === 'POST' && path === '/api/local/v1/runtimes/refresh') {
+                const runtimes = await this.bindings.refreshInstalledAgentRuntimes();
+                json(res, 200, { runtimes, checking: this.bindings.isRuntimeDetectionRunning() });
+                return;
+            }
+            if (req.method === 'POST' && path.startsWith('/api/local/v1/runtimes/') && path.endsWith('/refresh')) {
+                const runtimeId = decodeURIComponent(path.slice('/api/local/v1/runtimes/'.length, -'/refresh'.length));
+                const runtimes = await this.bindings.refreshInstalledAgentRuntimes(runtimeId);
+                json(res, 200, { runtimes, checking: this.bindings.isRuntimeDetectionRunning(runtimeId) });
+                return;
+            }
             if (req.method === 'GET' && path === '/api/local/v1/runtime/config') {
                 json(res, 200, await this.bindings.readConfigFile());
                 return;
@@ -264,6 +297,118 @@ class LocalAiCoreServer {
                 json(res, 200, { workspaces: await this.bindings.listWorkspaces() });
                 return;
             }
+            if (req.method === 'GET' && path === '/api/local/v1/workspace-registry') {
+                json(res, 200, { workspaces: await this.bindings.listWorkspaceRegistry() });
+                return;
+            }
+            if (req.method === 'POST' && path === '/api/local/v1/workspace-registry') {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createWorkspaceRegistryEntry(body));
+                return;
+            }
+            if (path.startsWith('/api/local/v1/workspace-registry/')) {
+                const workspaceId = decodeURIComponent(path.slice('/api/local/v1/workspace-registry/'.length));
+                if (req.method === 'GET') {
+                    json(res, 200, await this.bindings.getWorkspaceRegistryEntry(workspaceId));
+                    return;
+                }
+                if (req.method === 'PATCH') {
+                    const body = await readJsonBody(req);
+                    json(res, 200, await this.bindings.updateWorkspaceRegistryEntry(workspaceId, body));
+                    return;
+                }
+                if (req.method === 'DELETE') {
+                    json(res, 200, await this.bindings.deleteWorkspaceRegistryEntry(workspaceId));
+                    return;
+                }
+            }
+            if (path.startsWith('/api/local/v1/workspace-security/')) {
+                const workspaceId = decodeURIComponent(path.slice('/api/local/v1/workspace-security/'.length));
+                if (req.method === 'GET') {
+                    json(res, 200, await this.bindings.getWorkspaceSecuritySettings(workspaceId));
+                    return;
+                }
+                if (req.method === 'PATCH') {
+                    const body = await readJsonBody(req);
+                    json(res, 200, await this.bindings.updateWorkspaceSecuritySettings(workspaceId, body));
+                    return;
+                }
+            }
+            if (req.method === 'POST' && path === '/api/local/v1/security/command-risk') {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.classifyCommand(String(body.command || ''), String(body.workspaceId || '') || undefined));
+                return;
+            }
+            if (req.method === 'GET' && path === '/api/local/v1/approvals') {
+                const statusParam = url.searchParams.get('status') || '';
+                const status = statusParam ? statusParam.split(',').map((item) => item.trim()).filter(Boolean) : undefined;
+                json(res, 200, await this.bindings.listApprovalRequests({
+                    workspaceId: url.searchParams.get('workspace_id') || undefined,
+                    taskId: url.searchParams.get('task_id') || undefined,
+                    status,
+                    limit: Number(url.searchParams.get('limit') || '50'),
+                }));
+                return;
+            }
+            if (req.method === 'POST' && path === '/api/local/v1/approvals') {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createApprovalRequest(body));
+                return;
+            }
+            if (path.startsWith('/api/local/v1/approvals/')) {
+                const suffix = path.slice('/api/local/v1/approvals/'.length);
+                if (req.method === 'POST' && suffix.endsWith('/resolve')) {
+                    const approvalId = decodeURIComponent(suffix.slice(0, -'/resolve'.length));
+                    const body = await readJsonBody(req);
+                    json(res, 200, await this.bindings.resolveApprovalRequest(approvalId, body));
+                    return;
+                }
+                if (req.method === 'GET') {
+                    const approvalId = decodeURIComponent(suffix);
+                    json(res, 200, await this.bindings.getApprovalRequest(approvalId));
+                    return;
+                }
+            }
+            if (req.method === 'GET' && path === '/api/local/v1/audit-events') {
+                const typeParam = url.searchParams.get('type') || '';
+                const type = typeParam ? typeParam.split(',').map((item) => item.trim()).filter(Boolean) : undefined;
+                json(res, 200, await this.bindings.listAuditEvents({
+                    workspaceId: url.searchParams.get('workspace_id') || undefined,
+                    taskId: url.searchParams.get('task_id') || undefined,
+                    approvalId: url.searchParams.get('approval_id') || undefined,
+                    type,
+                    limit: Number(url.searchParams.get('limit') || '50'),
+                }));
+                return;
+            }
+            if (req.method === 'GET' && path === '/api/local/v1/tasks') {
+                const statusParam = url.searchParams.get('status') || '';
+                const status = statusParam ? statusParam.split(',').map((item) => item.trim()).filter(Boolean) : undefined;
+                json(res, 200, await this.bindings.listAgentTasks({
+                    workspaceId: url.searchParams.get('workspace_id') || undefined,
+                    runtimeId: url.searchParams.get('runtime_id') || undefined,
+                    status,
+                    limit: Number(url.searchParams.get('limit') || '50'),
+                }));
+                return;
+            }
+            if (req.method === 'POST' && path === '/api/local/v1/tasks') {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createAgentTask(body));
+                return;
+            }
+            if (path.startsWith('/api/local/v1/tasks/')) {
+                const taskId = decodeURIComponent(path.slice('/api/local/v1/tasks/'.length));
+                if (req.method === 'GET') {
+                    json(res, 200, await this.bindings.getAgentTask(taskId));
+                    return;
+                }
+                if (req.method === 'PATCH') {
+                    const body = await readJsonBody(req);
+                    json(res, 200, await this.bindings.updateAgentTask(taskId, body));
+                    return;
+                }
+            }
             if (req.method === 'GET' && path === '/api/local/v1/threads') {
                 const workspaceId = String(url.searchParams.get('workspace_id') || '');
                 json(res, 200, { threads: workspaceId ? await this.bindings.listThreads(workspaceId) : [] });
@@ -454,6 +599,12 @@ class LocalAiCoreServer {
             client.write(payload);
         }
     }
+    async runtimeDetectionResponse() {
+        return {
+            runtimes: await this.bindings.listInstalledAgentRuntimes(),
+            checking: this.bindings.isRuntimeDetectionRunning(),
+        };
+    }
     findThreadIdFromSessionKey(sessionKey) {
         const parts = sessionKey.split(':');
         if (parts.length < 3) {

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalScheduleAdapter = void 0;
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+class LocalScheduleAdapter {
+    options;
+    deliveryTargets = ['local'];
+    constructor(options) {
+        this.options = options;
+    }
+    supports(job) {
+        return job.platform === 'local' && (job.route.type === 'local.thread' || job.route.type === 'thread');
+    }
+    async execute(context) {
+        const { job } = context;
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const threadId = await this.resolveThread(job);
+        const sendResult = await workspaceRouter.sendThreadMessage(threadId, job.promptTemplate);
+        await this.waitForRun(sendResult.runId);
+        const thread = await workspaceRouter.getThread(threadId);
+        const replyText = [...thread.messages]
+            .reverse()
+            .find((message) => message.role === 'assistant' && message.kind === 'final')
+            ?.content;
+        return {
+            threadId,
+            runId: sendResult.runId,
+            replyText,
+        };
+    }
+    async resolveThread(job) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        if (job.route.threadId) {
+            await workspaceRouter.getThread(job.route.threadId);
+            return job.route.threadId;
+        }
+        const title = `[Scheduled] ${job.description || job.id}`;
+        const existing = (await workspaceRouter.listThreads(job.workspaceId))
+            .find((thread) => thread.title === title);
+        if (existing) {
+            return existing.id;
+        }
+        const created = await workspaceRouter.createThread(job.workspaceId, title);
+        return created.id;
+    }
+    async waitForRun(runId, timeoutMs = 15 * 60 * 1000) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            const run = this.options.store.getRun(runId);
+            if (run && TERMINAL_RUN_STATES.has(run.status)) {
+                if (run.status !== 'completed') {
+                    throw new Error(`Scheduled run finished with status ${run.status}`);
+                }
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        throw new Error(`Timed out waiting for scheduled run ${runId}`);
+    }
+}
+exports.LocalScheduleAdapter = LocalScheduleAdapter;

package/dist-electron/services/local-ai-core/src/security/command-risk.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyCommandRisk = classifyCommandRisk;
+function classifyCommandRisk(command) {
+    const normalized = command.trim();
+    const lower = normalized.toLowerCase();
+    const scopes = new Set(['command.execute']);
+    const reasons = [];
+    let riskLevel = 'low';
+    const highRiskPatterns = [
+        /\brm\s+(-[^\s]*r|-[^\s]*f|-rf|-fr)\b/,
+        /\bsudo\b/,
+        /\bchmod\s+(-?R\s+)?(777|[+]s)\b/,
+        /\bchown\s+(-?R\s+)?/,
+        /\bgit\s+(reset|clean|push|rebase)\b/,
+        /\bmkfs\b|\bdd\s+if=/,
+        /\b(security|pass|op|vault)\b.*\b(read|show|get)\b/,
+    ];
+    const mediumRiskPatterns = [
+        /\bnpm\s+(install|i|update)\b/,
+        /\bpnpm\s+(add|install|update)\b/,
+        /\byarn\s+(add|install|upgrade)\b/,
+        /\bcurl\b|\bwget\b/,
+        /\bgit\s+(checkout|merge|commit|pull)\b/,
+        /\bpython\d?\s+.*-m\s+pip\s+install\b/,
+    ];
+    if (highRiskPatterns.some((pattern) => pattern.test(lower))) {
+        riskLevel = 'high';
+        reasons.push('Command matches high-risk mutation, privilege, secret, or Git state rules.');
+    }
+    else if (mediumRiskPatterns.some((pattern) => pattern.test(lower))) {
+        riskLevel = 'medium';
+        reasons.push('Command may modify dependencies, network state, or Git working state.');
+    }
+    else {
+        reasons.push('Command does not match the current medium or high-risk rules.');
+    }
+    if (/\bcurl\b|\bwget\b|\bnpm\b|\bpnpm\b|\byarn\b|\bpip\b/.test(lower)) {
+        scopes.add('network.access');
+    }
+    if (/\bgit\s+(reset|clean|push|rebase|checkout|merge|commit|pull)\b/.test(lower)) {
+        scopes.add('git.modify');
+    }
+    if (/\brm\b|\bmv\b|\bcp\b|\bchmod\b|\bchown\b|\btouch\b|>\s*[^&]|\btee\b/.test(lower)) {
+        scopes.add('workspace.write');
+    }
+    if (/\b(secret|token|api[_-]?key|password|vault|op\s+read|pass\s+show)\b/.test(lower)) {
+        scopes.add('secrets.access');
+    }
+    return {
+        command: normalized,
+        riskLevel,
+        scopes: [...scopes],
+        reasons,
+        requiresApproval: riskLevel !== 'low',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafca/agentdock",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "main": "dist-electron/electron/main.js",
   "bin": {