@kafca/agentdock 0.1.41 → 0.1.43

package/dist-electron/services/local-ai-core/src/acp/local-core-slash-commands.js

@@ -5,7 +5,17 @@ exports.parseSlashCommand = parseSlashCommand;
 exports.normalizeAgentMode = normalizeAgentMode;
 exports.formatAgentMode = formatAgentMode;
 exports.modeHelpText = modeHelpText;
+exports.normalizeAgentCommandTarget = normalizeAgentCommandTarget;
+exports.formatAgentList = formatAgentList;
+exports.agentHelpText = agentHelpText;
 exports.DEFAULT_AGENT_MODE = 'default';
+const AGENT_ALIASES = {
+    claude: 'claudecode',
+    'claude-code': 'claudecode',
+    claude_code: 'claudecode',
+    claudecode: 'claudecode',
+    cc: 'claudecode',
+};
 const MODE_ALIASES = {
     auto: 'auto',
     default: 'default',
@@ -58,3 +68,21 @@ function modeHelpText(currentMode) {
         '`/mode yolo` 会跳过工具权限申请；使用 `/mode default` 可恢复默认权限。'
     ].join('\n');
 }
+function normalizeAgentCommandTarget(agent) {
+    const key = String(agent || '').trim().toLowerCase();
+    return AGENT_ALIASES[key] || key;
+}
+function formatAgentList(agents) {
+    return [...new Set(agents.map(normalizeAgentCommandTarget).filter(Boolean))].sort();
+}
+function agentHelpText(input) {
+    const currentAgent = normalizeAgentCommandTarget(input.currentAgent) || 'unknown';
+    const defaultAgent = normalizeAgentCommandTarget(input.defaultAgent) || 'unknown';
+    const availableAgents = formatAgentList(input.availableAgents);
+    return [
+        `当前线程 Agent：${currentAgent}`,
+        `默认 Agent：${defaultAgent}`,
+        `可用 Agent：${availableAgents.length ? availableAgents.join(', ') : '无'}`,
+        '可用命令：`/agent list`、`/agent current`、`/agent use <agent-id>`、`/agent reset`。',
+    ].join('\n');
+}

package/dist-electron/services/local-ai-core/src/acp/store/agent-task-store.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAgentTaskStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+const utils_js_1 = require("./utils.js");
+class LocalAgentTaskStore {
+    db;
+    createAuditEvent;
+    constructor(db, createAuditEvent) {
+        this.db = db;
+        this.createAuditEvent = createAuditEvent;
+    }
+    create(input) {
+        const id = `task:${(0, node_crypto_1.randomUUID)()}`;
+        const now = new Date().toISOString();
+        const status = (0, index_js_1.normalizeAgentTaskStatus)(input.status);
+        const timeline = [{
+                id: `timeline:${(0, node_crypto_1.randomUUID)()}`,
+                type: 'status_change',
+                title: `Task ${status}`,
+                status,
+                timestamp: now,
+            }];
+        this.db.prepare(`
+      INSERT INTO agent_tasks (
+        id, workspace_id, device_id, runtime_id, thread_id, run_id, title, prompt, status, created_at, updated_at, queued_at,
+        started_at, completed_at, summary, error, timeline_json, logs_json, artifacts_json, approval_ids_json, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, ?, '[]', '[]', '[]', ?)
+    `).run(id, input.workspaceId, input.deviceId, input.runtimeId, input.threadId || null, input.runId || null, input.title, input.prompt ? (0, utils_js_1.redactSecrets)(input.prompt) : null, status, now, now, status === 'queued' ? now : null, status === 'running' ? now : null, JSON.stringify(timeline), JSON.stringify(input.metadata || {}));
+        const task = this.get(id);
+        this.createAuditEvent({
+            type: 'task.created',
+            workspaceId: task.workspaceId,
+            taskId: task.taskId,
+            actor: 'local',
+            summary: `Task created: ${task.title}`,
+            metadata: { runtimeId: task.runtimeId, threadId: task.threadId, runId: task.runId },
+        });
+        return task;
+    }
+    list(query = {}) {
+        const predicates = [];
+        const params = [];
+        if (query.workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(query.workspaceId);
+        }
+        if (query.runtimeId) {
+            predicates.push('runtime_id = ?');
+            params.push(query.runtimeId);
+        }
+        if (query.status) {
+            const statuses = (Array.isArray(query.status) ? query.status : [query.status]).map((status) => (0, index_js_1.normalizeAgentTaskStatus)(status));
+            predicates.push(`status IN (${statuses.map(() => '?').join(', ')})`);
+            params.push(...statuses);
+        }
+        const limit = Math.max(1, Math.min(Number(query.limit || 50), 100));
+        const where = predicates.length ? `WHERE ${predicates.join(' AND ')}` : '';
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM agent_tasks
+      ${where}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(...params, limit);
+        return { tasks: rows.map((row) => this.toAgentTask(row)) };
+    }
+    get(taskId) {
+        const row = this.db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
+        return row ? this.toAgentTask(row) : undefined;
+    }
+    getByRunId(runId) {
+        const row = this.db.prepare('SELECT * FROM agent_tasks WHERE run_id = ? ORDER BY updated_at DESC LIMIT 1').get(runId);
+        return row ? this.toAgentTask(row) : undefined;
+    }
+    update(taskId, input) {
+        const existing = this.get(taskId);
+        if (!existing) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const now = new Date().toISOString();
+        const nextStatus = input.status ? (0, index_js_1.normalizeAgentTaskStatus)(input.status) : existing.status;
+        const timeline = [...existing.timeline];
+        const logs = [...existing.logs];
+        const artifacts = [...existing.artifacts];
+        const approvalIds = [...existing.approvalIds];
+        if (input.status && nextStatus !== existing.status) {
+            timeline.push({
+                id: `timeline:${(0, node_crypto_1.randomUUID)()}`,
+                type: 'status_change',
+                title: `Task ${nextStatus}`,
+                status: nextStatus,
+                timestamp: now,
+            });
+        }
+        if (input.timelineItem) {
+            timeline.push({
+                id: input.timelineItem.id || `timeline:${(0, node_crypto_1.randomUUID)()}`,
+                timestamp: input.timelineItem.timestamp || now,
+                ...input.timelineItem,
+            });
+        }
+        if (input.log) {
+            logs.push({
+                id: input.log.id || `log:${(0, node_crypto_1.randomUUID)()}`,
+                timestamp: input.log.timestamp || now,
+                ...input.log,
+                message: (0, utils_js_1.redactSecrets)(input.log.message),
+            });
+        }
+        if (input.artifact) {
+            artifacts.push({
+                id: input.artifact.id || `artifact:${(0, node_crypto_1.randomUUID)()}`,
+                ...input.artifact,
+            });
+        }
+        if (input.approvalId && !approvalIds.includes(input.approvalId)) {
+            approvalIds.push(input.approvalId);
+        }
+        this.db.prepare(`
+      UPDATE agent_tasks
+      SET status = ?, thread_id = ?, run_id = ?, title = ?, updated_at = ?, queued_at = ?, started_at = ?, completed_at = ?,
+          summary = ?, error = ?, timeline_json = ?, logs_json = ?, artifacts_json = ?, approval_ids_json = ?, metadata_json = ?
+      WHERE id = ?
+    `).run(nextStatus, input.threadId || existing.threadId || null, input.runId || existing.runId || null, input.title || existing.title, now, existing.queuedAt || (nextStatus === 'queued' ? now : null), existing.startedAt || (nextStatus === 'running' ? now : null), existing.completedAt || (['completed', 'failed', 'cancelled'].includes(nextStatus) ? now : null), input.summary ?? existing.summary ?? null, input.error === null ? null : input.error ?? existing.error ?? null, JSON.stringify(timeline), JSON.stringify(logs), JSON.stringify(artifacts), JSON.stringify(approvalIds), JSON.stringify(input.metadata || existing.metadata || {}), taskId);
+        const task = this.get(taskId);
+        if (input.status && nextStatus !== existing.status) {
+            this.createAuditEvent({
+                type: 'task.updated',
+                workspaceId: task.workspaceId,
+                taskId: task.taskId,
+                actor: 'local',
+                summary: `Task status changed to ${nextStatus}.`,
+                metadata: { previousStatus: existing.status, status: nextStatus, runId: task.runId },
+            });
+        }
+        return task;
+    }
+    toAgentTask(row) {
+        return {
+            taskId: row.id,
+            workspaceId: row.workspace_id,
+            deviceId: row.device_id,
+            runtimeId: row.runtime_id,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            title: row.title,
+            prompt: row.prompt || undefined,
+            status: (0, index_js_1.normalizeAgentTaskStatus)(row.status),
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            queuedAt: row.queued_at || undefined,
+            startedAt: row.started_at || undefined,
+            completedAt: row.completed_at || undefined,
+            summary: row.summary || undefined,
+            error: row.error || undefined,
+            timeline: (0, utils_js_1.parseJson)(row.timeline_json, []),
+            logs: (0, utils_js_1.parseJson)(row.logs_json, []),
+            artifacts: (0, utils_js_1.parseJson)(row.artifacts_json, []),
+            approvalIds: (0, utils_js_1.parseJson)(row.approval_ids_json, []),
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+}
+exports.LocalAgentTaskStore = LocalAgentTaskStore;

package/dist-electron/services/local-ai-core/src/acp/store/automation-monitor-store.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAutomationMonitorStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+class LocalAutomationMonitorStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    list(workspaceId) {
+        const query = workspaceId
+            ? `
+        SELECT id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+               execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at, last_triggered_at, last_status, last_error
+        FROM automation_monitors
+        WHERE workspace_id = ?
+        ORDER BY updated_at DESC
+      `
+            : `
+        SELECT id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+               execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at, last_triggered_at, last_status, last_error
+        FROM automation_monitors
+        ORDER BY updated_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...(workspaceId ? [workspaceId] : []));
+        return rows.map((row) => this.toMonitor(row));
+    }
+    get(monitorId) {
+        const row = this.db.prepare(`
+      SELECT id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+             execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at, last_triggered_at, last_status, last_error
+      FROM automation_monitors
+      WHERE id = ?
+    `).get(monitorId);
+        return row ? this.toMonitor(row) : undefined;
+    }
+    create(input) {
+        const title = String(input.title || '').trim();
+        if (!title)
+            throw new Error('Automation monitor title is required.');
+        const sourceType = String(input.sourceType || '').trim();
+        if (!sourceType)
+            throw new Error('Automation monitor source type is required.');
+        const condition = {
+            ...input.condition,
+            metric: String(input.condition?.metric || '').trim(),
+            operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(input.condition?.operator),
+        };
+        if (!condition.metric)
+            throw new Error('Automation monitor condition metric is required.');
+        const id = this.createMonitorId();
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO automation_monitors (
+        id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+        execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'skip_if_running', ?, ?, ?)
+    `).run(id, input.workspaceId, title, sourceType, JSON.stringify(input.sourceConfig || {}), JSON.stringify(condition), input.promptTemplate, (0, index_js_1.normalizeChannelPlatform)(input.platform), input.route.type, JSON.stringify(input.route), (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode, 'side-thread'), input.enabled === false ? 0 : 1, Math.max(0, Number(input.cooldownMs ?? 15 * 60 * 1000)), null, now, now);
+        return this.get(id);
+    }
+    update(monitorId, input) {
+        const existing = this.get(monitorId);
+        if (!existing)
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        const nextCondition = input.condition
+            ? {
+                ...input.condition,
+                metric: String(input.condition.metric || '').trim(),
+                operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(input.condition.operator),
+            }
+            : existing.condition;
+        const next = {
+            ...existing,
+            ...(typeof input.title === 'string' ? { title: input.title.trim() } : {}),
+            ...(input.sourceConfig ? { sourceConfig: input.sourceConfig } : {}),
+            condition: nextCondition,
+            ...(typeof input.promptTemplate === 'string' ? { promptTemplate: input.promptTemplate } : {}),
+            ...(input.route ? { route: input.route } : {}),
+            ...(input.executionMode ? { executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode, 'side-thread') } : {}),
+            ...(typeof input.enabled === 'boolean' ? { enabled: input.enabled } : {}),
+            ...(typeof input.cooldownMs === 'number' ? { cooldownMs: Math.max(0, input.cooldownMs) } : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        if (!next.title)
+            throw new Error('Automation monitor title is required.');
+        this.db.prepare(`
+      UPDATE automation_monitors
+      SET title = ?, source_config_json = ?, condition_json = ?, prompt_template = ?, route_type = ?, route_config = ?,
+          execution_mode = ?, enabled = ?, cooldown_ms = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.title, JSON.stringify(next.sourceConfig || {}), JSON.stringify(next.condition), next.promptTemplate, next.route.type, JSON.stringify(next.route), next.executionMode, next.enabled ? 1 : 0, next.cooldownMs, next.updatedAt, monitorId);
+        return this.get(monitorId);
+    }
+    updateState(monitorId, input) {
+        this.db.prepare(`
+      UPDATE automation_monitors
+      SET last_state_json = CASE WHEN ? IS NULL THEN last_state_json ELSE ? END,
+          last_triggered_at = COALESCE(?, last_triggered_at),
+          last_status = COALESCE(?, last_status),
+          last_error = CASE WHEN ? IS NULL THEN last_error ELSE ? END,
+          enabled = CASE WHEN ? IS NULL THEN enabled ELSE ? END,
+          updated_at = ?
+      WHERE id = ?
+    `).run(input.lastState == null ? null : JSON.stringify(input.lastState), input.lastState == null ? null : JSON.stringify(input.lastState), input.lastTriggeredAt || null, input.lastStatus || null, input.lastError == null ? null : input.lastError, input.lastError == null ? null : input.lastError, typeof input.enabled === 'boolean' ? (input.enabled ? 1 : 0) : null, typeof input.enabled === 'boolean' ? (input.enabled ? 1 : 0) : null, new Date().toISOString(), monitorId);
+    }
+    delete(monitorId) {
+        const result = this.db.prepare('DELETE FROM automation_monitors WHERE id = ?').run(monitorId);
+        if (result.changes === 0)
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        return { deleted: true };
+    }
+    listRuns(monitorId) {
+        const rows = this.db.prepare(`
+      SELECT id, monitor_id, status, triggered_at, started_at, finished_at, error, event_snapshot_json, thread_id, run_id, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM automation_monitor_runs
+      WHERE monitor_id = ?
+      ORDER BY triggered_at DESC
+    `).all(monitorId);
+        return rows.map((row) => this.toRun(row));
+    }
+    createRun(monitorId, status, input = {}) {
+        const id = `monitorrun:${(0, node_crypto_1.randomUUID)()}`;
+        const triggeredAt = input.triggeredAt || new Date().toISOString();
+        const normalizedStatus = (0, index_js_1.normalizeAutomationMonitorStatus)(status);
+        this.db.prepare(`
+      INSERT INTO automation_monitor_runs (id, monitor_id, status, triggered_at, started_at, finished_at, error, event_snapshot_json, thread_id, run_id, delivery_mode, delivery_status, delivery_error, last_bridge_event_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, monitorId, normalizedStatus, triggeredAt, input.startedAt || null, input.finishedAt || null, input.error || null, input.eventSnapshot ? JSON.stringify(input.eventSnapshot) : null, input.threadId || null, input.runId || null, input.deliveryMode || null, input.deliveryStatus || null, input.deliveryError || null, input.lastBridgeEventAt || null);
+        this.updateState(monitorId, {
+            lastTriggeredAt: triggeredAt,
+            lastStatus: normalizedStatus,
+            lastError: input.error || '',
+        });
+        return this.getRun(id);
+    }
+    getRun(runId) {
+        const row = this.db.prepare(`
+      SELECT id, monitor_id, status, triggered_at, started_at, finished_at, error, event_snapshot_json, thread_id, run_id, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM automation_monitor_runs
+      WHERE id = ?
+    `).get(runId);
+        return row ? this.toRun(row) : undefined;
+    }
+    updateRun(runId, input) {
+        const existing = this.getRun(runId);
+        if (!existing)
+            throw new Error(`Automation monitor run not found: ${runId}`);
+        const next = {
+            ...existing,
+            ...input,
+            ...(input.status ? { status: (0, index_js_1.normalizeAutomationMonitorStatus)(input.status) } : {}),
+        };
+        this.db.prepare(`
+      UPDATE automation_monitor_runs
+      SET status = ?, triggered_at = ?, started_at = ?, finished_at = ?, error = ?, event_snapshot_json = ?, thread_id = ?, run_id = ?, delivery_mode = ?, delivery_status = ?, delivery_error = ?, last_bridge_event_at = ?
+      WHERE id = ?
+    `).run(next.status, next.triggeredAt, next.startedAt || null, next.finishedAt || null, next.error || null, next.eventSnapshot ? JSON.stringify(next.eventSnapshot) : null, next.threadId || null, next.runId || null, next.deliveryMode || null, next.deliveryStatus || null, next.deliveryError || null, next.lastBridgeEventAt || null, runId);
+        if (input.status || Object.prototype.hasOwnProperty.call(input, 'error') || input.finishedAt || input.triggeredAt) {
+            this.updateState(existing.monitorId, {
+                lastTriggeredAt: next.triggeredAt,
+                lastStatus: next.status,
+                lastError: next.error || '',
+            });
+        }
+        return this.getRun(runId);
+    }
+    toMonitor(row) {
+        const condition = parseJson(row.condition_json, {});
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            title: row.title,
+            sourceType: row.source_type,
+            sourceConfig: parseJson(row.source_config_json || '{}', {}),
+            condition: {
+                ...condition,
+                operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(condition.operator),
+            },
+            promptTemplate: row.prompt_template,
+            platform: (0, index_js_1.normalizeChannelPlatform)(row.platform),
+            route: JSON.parse(row.route_config),
+            executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(row.execution_mode, 'side-thread'),
+            enabled: Boolean(row.enabled),
+            cooldownMs: Number(row.cooldown_ms || 0),
+            concurrencyPolicy: row.concurrency_policy,
+            lastState: row.last_state_json ? parseJson(row.last_state_json, {}) : undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastTriggeredAt: row.last_triggered_at || undefined,
+            lastStatus: row.last_status ? (0, index_js_1.normalizeAutomationMonitorStatus)(row.last_status) : undefined,
+            lastError: row.last_error || undefined,
+        };
+    }
+    toRun(row) {
+        return {
+            id: row.id,
+            monitorId: row.monitor_id,
+            status: (0, index_js_1.normalizeAutomationMonitorStatus)(row.status),
+            triggeredAt: row.triggered_at,
+            startedAt: row.started_at || undefined,
+            finishedAt: row.finished_at || undefined,
+            error: row.error || undefined,
+            eventSnapshot: row.event_snapshot_json ? parseJson(row.event_snapshot_json, {}) : undefined,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            deliveryMode: row.delivery_mode || undefined,
+            deliveryStatus: row.delivery_status || undefined,
+            deliveryError: row.delivery_error || undefined,
+            lastBridgeEventAt: row.last_bridge_event_at || undefined,
+        };
+    }
+    createMonitorId() {
+        let id = `monitor:${(0, node_crypto_1.randomUUID)()}`;
+        for (let attempt = 0; attempt < 5 && this.get(id); attempt += 1) {
+            id = `monitor:${(0, node_crypto_1.randomUUID)()}`;
+        }
+        if (this.get(id))
+            throw new Error('Unable to allocate a unique automation monitor id.');
+        return id;
+    }
+}
+exports.LocalAutomationMonitorStore = LocalAutomationMonitorStore;
+function parseJson(value, fallback) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}