@kafca/agentdock 0.1.7

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreAcpTransport = void 0;
+const node_child_process_1 = require("node:child_process");
+class LocalCoreAcpTransport {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    spawnSession(input) {
+        const baseEnv = {
+            ...process.env,
+            ...input.config.env,
+        };
+        const child = (0, node_child_process_1.spawn)(input.config.command, input.config.args, {
+            cwd: input.config.workDir,
+            env: {
+                ...baseEnv,
+                ...input.runtimeEnv,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const session = {
+            child,
+            requestId: 0,
+            stdoutBuffer: '',
+            pending: new Map(),
+            sessionId: '',
+            supportsLoad: false,
+            workspaceId: input.config.workspaceId,
+            threadId: input.threadId,
+            bridgeSessionKey: input.bridgeSessionKey,
+            currentRunId: null,
+            currentTurn: null,
+            loadReplayMode: false,
+            pendingPermissionByRun: new Map(),
+            schedulerJobCreatedByRun: new Map(),
+            closed: false,
+            closeReason: null,
+            promptPromise: null,
+        };
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.handleStdout(session, chunk));
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            this.options.log?.(`[localcore-acp:${input.threadId}] ${chunk.trimEnd()}`);
+        });
+        child.stdin.on('error', (error) => {
+            this.handlePipeFailure(session, error);
+        });
+        child.on('exit', (code, signal) => {
+            this.options.onSessionClosed(session, new Error(`ACP agent exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}`));
+        });
+        return session;
+    }
+    async initializeSession(session) {
+        const initResult = await this.request(session, 'initialize', {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: {
+                    readTextFile: false,
+                    writeTextFile: false,
+                },
+                terminal: false,
+            },
+            clientInfo: {
+                name: 'agentdock',
+                title: 'AgentDock',
+                version: '0.1.0',
+            },
+        }, 30000);
+        session.supportsLoad = Boolean(initResult?.agentCapabilities?.loadSession);
+    }
+    request(session, method, params, timeoutMs = 30000) {
+        session.requestId += 1;
+        const id = session.requestId;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                session.pending.delete(id);
+                reject(new Error(`Timed out waiting for ACP ${method} after ${timeoutMs}ms`));
+            }, timeoutMs);
+            session.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timeout);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+            });
+            if (!this.sendRaw(session, {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params,
+            })) {
+                session.pending.delete(id);
+                reject(new Error(session.closeReason || 'ACP session is not writable'));
+            }
+        });
+    }
+    sendRaw(session, payload) {
+        if (session.closed || !session.child.stdin.writable) {
+            return false;
+        }
+        try {
+            session.child.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+                if (error) {
+                    this.handlePipeFailure(session, error);
+                }
+            });
+            return true;
+        }
+        catch (error) {
+            this.handlePipeFailure(session, error);
+            return false;
+        }
+    }
+    closeSession(session, reason = 'ACP session closed') {
+        if (session.closed) {
+            return;
+        }
+        session.closed = true;
+        session.closeReason = reason;
+        if (!session.child.killed) {
+            session.child.kill('SIGTERM');
+        }
+    }
+    closeSessionWithError(session, error) {
+        if (session.closed) {
+            return;
+        }
+        session.closed = true;
+        session.closeReason = error.message;
+        for (const pending of session.pending.values()) {
+            pending.reject(error);
+        }
+        session.pending.clear();
+        if (!session.child.killed) {
+            session.child.kill('SIGTERM');
+        }
+    }
+    handleStdout(session, chunk) {
+        session.stdoutBuffer += chunk;
+        while (session.stdoutBuffer.includes('\n')) {
+            const newlineIndex = session.stdoutBuffer.indexOf('\n');
+            const line = session.stdoutBuffer.slice(0, newlineIndex).trim();
+            session.stdoutBuffer = session.stdoutBuffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(line);
+            }
+            catch (error) {
+                this.options.log?.(`ACP stdout parse failed: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            if (payload.method && payload.id !== undefined) {
+                this.options.onAgentRequest(session, payload);
+                continue;
+            }
+            if (payload.method) {
+                this.options.onAgentNotification(session, payload);
+                continue;
+            }
+            if (payload.id !== undefined) {
+                const pending = session.pending.get(payload.id);
+                if (!pending) {
+                    continue;
+                }
+                session.pending.delete(payload.id);
+                if (payload.error) {
+                    pending.reject(new Error(payload.error.message || `ACP request failed: ${payload.id}`));
+                }
+                else {
+                    pending.resolve(payload.result);
+                }
+            }
+        }
+    }
+    handlePipeFailure(session, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.options.log?.(`[localcore-acp:${session.threadId}] stdin failure: ${message}`);
+        this.options.onSessionClosed(session, new Error(message));
+    }
+}
+exports.LocalCoreAcpTransport = LocalCoreAcpTransport;

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreAcpTurnCoordinator = void 0;
+const desktop_js_1 = require("../../../../shared/desktop.js");
+const workspace_acp_permissions_js_1 = require("./workspace-acp-permissions.js");
+class LocalCoreAcpTurnCoordinator {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    flushPendingToolCall(session) {
+        const currentTurn = session.currentTurn;
+        const currentRunId = session.currentRunId;
+        const title = currentTurn?.pendingToolCallTitle?.trim();
+        if (!currentTurn || !currentRunId || !title) {
+            return;
+        }
+        currentTurn.pendingToolCallTitle = undefined;
+        this.emitProgress(session, currentRunId, `🔧 ${title}`);
+    }
+    getPendingPermissionRequest(session, detail) {
+        const runId = session?.currentRunId;
+        if (!session || !runId) {
+            return null;
+        }
+        const pendingPermission = session.pendingPermissionByRun.get(runId);
+        if (!pendingPermission) {
+            return null;
+        }
+        const latestAssistantMessage = [...detail.messages].reverse().find((message) => message.role === 'assistant');
+        return {
+            id: latestAssistantMessage?.id || `${runId}-buttons`,
+            content: latestAssistantMessage?.content || 'Permission required before continuing.',
+            actions: (0, workspace_acp_permissions_js_1.toPermissionButtonRows)(pendingPermission.options, desktop_js_1.normalizeDesktopBridgeButtonOption),
+            actionReplyCtx: runId,
+            actionPending: false,
+            actionStatus: undefined,
+            actionMode: 'permission',
+            actionInteractive: true,
+        };
+    }
+    handleAgentRequest(session, payload) {
+        if (payload.method !== 'session/request_permission') {
+            this.options.sendRaw(session, {
+                jsonrpc: '2.0',
+                id: payload.id,
+                error: {
+                    code: -32601,
+                    message: `Unsupported ACP client method: ${String(payload.method || '')}`,
+                },
+            });
+            return;
+        }
+        const currentRunId = session.currentRunId;
+        if (!currentRunId) {
+            this.options.sendRaw(session, {
+                jsonrpc: '2.0',
+                id: payload.id,
+                result: {
+                    outcome: {
+                        outcome: 'cancelled',
+                    },
+                },
+            });
+            return;
+        }
+        const options = Array.isArray(payload.params?.options)
+            ? payload.params.options
+                .map((option) => ({
+                optionId: String(option?.optionId || '').trim(),
+                name: String(option?.name || option?.optionId || '').trim(),
+                kind: String(option?.kind || '').trim(),
+                normalizedAction: (0, workspace_acp_permissions_js_1.normalizePermissionAction)(option?.kind),
+            }))
+                .filter((option) => option.optionId)
+            : [];
+        const toolTitle = (0, workspace_acp_permissions_js_1.formatToolCallContent)(payload.params?.toolCall);
+        const isSchedulerAdd = isSchedulerAddCommand(toolTitle);
+        if (isSchedulerAdd && session.schedulerJobCreatedByRun.get(currentRunId)) {
+            this.options.sendRaw(session, {
+                jsonrpc: '2.0',
+                id: payload.id,
+                result: {
+                    outcome: {
+                        outcome: 'cancelled',
+                    },
+                },
+            });
+            const content = '已限制本次对话只创建一个定时任务，额外的 scheduler add 请求已自动取消。';
+            this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+            this.options.emitBridge({
+                type: 'reply',
+                sessionKey: session.bridgeSessionKey,
+                replyCtx: currentRunId,
+                content,
+            });
+            return;
+        }
+        const buttonRows = (0, workspace_acp_permissions_js_1.toPermissionButtonRows)(options, desktop_js_1.normalizeDesktopBridgeButtonOption);
+        const permissionRequest = {
+            requestId: payload.id,
+            toolTitle,
+            isSchedulerAdd,
+            options,
+        };
+        session.pendingPermissionByRun.set(currentRunId, permissionRequest);
+        if (session.currentTurn) {
+            session.currentTurn.permission = permissionRequest;
+        }
+        this.options.updateRunStatus(currentRunId, session.threadId, 'awaiting_input');
+        const permissionPrompt = [
+            '等待工具确认',
+            '',
+            toolTitle,
+            '',
+            '请选择一个选项继续执行。',
+            '',
+            '若按钮没有显示，请直接回复：allow all / allow / deny',
+        ].join('\n');
+        this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress');
+        this.options.emitBridge({
+            type: 'buttons',
+            sessionKey: session.bridgeSessionKey,
+            replyCtx: currentRunId,
+            content: permissionPrompt,
+            buttonRows,
+        });
+    }
+    handleAgentNotification(session, payload) {
+        if (session.loadReplayMode || payload.method !== 'session/update') {
+            return;
+        }
+        const update = payload.params?.update;
+        const currentTurn = session.currentTurn;
+        const currentRunId = session.currentRunId;
+        if (!update || !currentTurn || !currentRunId) {
+            return;
+        }
+        switch (String(update.sessionUpdate || '')) {
+            case 'agent_message_chunk': {
+                this.flushPendingToolCall(session);
+                if (update.content?.type !== 'text') {
+                    return;
+                }
+                currentTurn.assistantText += String(update.content.text || '');
+                if (!currentTurn.previewStarted) {
+                    currentTurn.previewStarted = true;
+                    this.options.emitBridge({
+                        type: 'preview_start',
+                        sessionKey: session.bridgeSessionKey,
+                        replyCtx: currentRunId,
+                        previewHandle: currentTurn.previewHandle,
+                        content: currentTurn.assistantText,
+                    });
+                    return;
+                }
+                this.options.emitBridge({
+                    type: 'update_message',
+                    sessionKey: session.bridgeSessionKey,
+                    replyCtx: currentRunId,
+                    previewHandle: currentTurn.previewHandle,
+                    content: currentTurn.assistantText,
+                });
+                return;
+            }
+            case 'tool_call': {
+                const title = String(update.title || 'Running tool').trim();
+                this.flushPendingToolCall(session);
+                currentTurn.pendingToolCallTitle = title;
+                return;
+            }
+            case 'tool_call_update': {
+                const title = String(update.title || 'Tool update').trim();
+                const status = String(update.status || '').trim();
+                const content = this.extractToolUpdateContent(update.content);
+                if (isSchedulerAddCommand(title) && /Created scheduler job\b/.test(content)) {
+                    session.schedulerJobCreatedByRun.set(currentRunId, true);
+                }
+                const toolName = currentTurn.pendingToolCallTitle?.trim();
+                if (this.isEmptyRunningToolUpdate(title, status, content)) {
+                    currentTurn.pendingToolCallTitle = undefined;
+                    return;
+                }
+                currentTurn.pendingToolCallTitle = undefined;
+                this.emitProgress(session, currentRunId, this.formatToolProgressMessage(toolName, title, status, content));
+                return;
+            }
+            case 'plan': {
+                this.flushPendingToolCall(session);
+                const entries = Array.isArray(update.entries) ? update.entries : [];
+                if (entries.length === 0) {
+                    return;
+                }
+                const summary = entries
+                    .map((entry) => String(entry?.content || '').trim())
+                    .filter(Boolean)
+                    .join(' | ');
+                const content = `💭 ${summary}`;
+                this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+                this.options.emitBridge({
+                    type: 'reply',
+                    sessionKey: session.bridgeSessionKey,
+                    replyCtx: currentRunId,
+                    content,
+                });
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    emitProgress(session, currentRunId, content) {
+        this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+        this.options.emitBridge({
+            type: 'reply',
+            sessionKey: session.bridgeSessionKey,
+            replyCtx: currentRunId,
+            content,
+        });
+    }
+    extractToolUpdateContent(content) {
+        return Array.isArray(content)
+            ? content
+                .map((entry) => entry?.type === 'content' && entry?.content?.type === 'text'
+                ? String(entry.content.text || '')
+                : '')
+                .filter(Boolean)
+                .join('\n')
+            : '';
+    }
+    formatToolProgressMessage(toolName, title, status, content) {
+        const detail = [title, status, content].filter(Boolean).join(' - ');
+        return toolName ? `🔧 ${toolName}: ${detail || 'Tool update'}` : `🔧 ${detail || 'Tool update'}`;
+    }
+    isEmptyRunningToolUpdate(title, status, content) {
+        return !content.trim() &&
+            /^running$/i.test(status) &&
+            (!title.trim() || /^tool update$/i.test(title));
+    }
+}
+exports.LocalCoreAcpTurnCoordinator = LocalCoreAcpTurnCoordinator;
+function isSchedulerAddCommand(value) {
+    return /\blac\s+scheduler\s+add\b/.test(String(value || ''));
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePermissionAction = normalizePermissionAction;
+exports.formatToolCallContent = formatToolCallContent;
+exports.toPermissionButtonRows = toPermissionButtonRows;
+function normalizePermissionAction(kind) {
+    const normalized = String(kind || '').trim().toLowerCase();
+    if (normalized === 'allow_always') {
+        return 'allow all';
+    }
+    if (normalized.startsWith('allow')) {
+        return 'allow';
+    }
+    if (normalized.startsWith('reject')) {
+        return 'deny';
+    }
+    return '';
+}
+function formatToolCallContent(toolCall) {
+    if (!toolCall || typeof toolCall !== 'object') {
+        return 'Permission required before continuing.';
+    }
+    const title = typeof toolCall.title === 'string' ? toolCall.title.trim() : '';
+    const content = Array.isArray(toolCall.content)
+        ? toolCall.content
+            .map((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                return '';
+            }
+            if (typeof entry.text === 'string') {
+                return String(entry.text).trim();
+            }
+            const nested = entry.content;
+            return nested?.type === 'text' ? String(nested.text || '').trim() : '';
+        })
+            .filter(Boolean)
+            .join('\n')
+        : '';
+    return [title, content].filter(Boolean).join('\n\n') || 'Permission required before continuing.';
+}
+function toPermissionButtonRows(options, normalizeButton) {
+    return [options.map((option) => {
+            const data = option.normalizedAction
+                ? `perm:${option.normalizedAction.replace(/\s+/g, '_')}`
+                : option.optionId;
+            const normalized = normalizeButton({
+                text: option.normalizedAction || option.name,
+                data,
+            });
+            return normalized || { text: option.name, data: option.optionId };
+        })];
+}