@kafca/agentdock 0.1.29 → 0.1.31

package/dist-electron/electron/plugin-kernel.test.js

@@ -16,6 +16,7 @@ const event_bus_js_1 = require("../services/local-ai-core/src/kernel/event-bus.j
 const lifecycle_manager_js_1 = require("../services/local-ai-core/src/kernel/lifecycle-manager.js");
 const plugin_registry_js_1 = require("../services/local-ai-core/src/kernel/plugin-registry.js");
 const local_core_controller_js_1 = require("../services/local-ai-core/src/runtime/local-core-controller.js");
+const local_core_runtime_state_js_1 = require("../services/local-ai-core/src/runtime/local-core-runtime-state.js");
 const server_js_1 = require("../services/local-ai-core/src/runtime/server.js");
 function plugin(id, dependsOn = []) {
     return {
@@ -159,6 +160,7 @@ function plugin(id, dependsOn = []) {
             'opencode',
             'codex',
             'claudecode',
+            'hermes',
         ]);
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().adapters.channels, ['localcore-acp', 'lark', 'weixin']);
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().adapters.knowledgeProviders, ['ai-vector']);
@@ -193,6 +195,7 @@ function plugin(id, dependsOn = []) {
             'opencode',
             'codex',
             'claudecode',
+            'hermes',
         ]);
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().adapters.channels, ['localcore-acp', 'lark', 'weixin']);
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().adapters.knowledgeProviders, []);
@@ -245,6 +248,44 @@ type = "codex"
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('hermes agent runtime routes projects through hermes ACP command', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
+    try {
+        const runtime = (0, bootstrap_js_2.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+        });
+        await runtime.state.saveRawConfigFile(`
+[[projects]]
+name = "hermes-workspace"
+
+[projects.agent]
+type = "hermes"
+`);
+        const configState = await runtime.state.readConfigFile();
+        const project = configState.parsed?.projects?.find((entry) => entry.name === 'hermes-workspace');
+        const hermesRuntime = runtime.agentRuntimes.find((entry) => entry.agentType === 'hermes');
+        const route = project ? hermesRuntime?.createRoute(configState, project) : null;
+        strict_1.default.equal(route?.agentType, 'hermes');
+        strict_1.default.equal(route?.config.command, 'hermes');
+        strict_1.default.deepEqual(route?.config.args, ['acp']);
+        strict_1.default.equal(route?.config.env?.HERMES_YOLO_MODE, '1');
+        strict_1.default.deepEqual(await runtime.workspaceRouter.listWorkspaces(), [
+            {
+                id: 'hermes-workspace',
+                name: 'hermes-workspace',
+                agentType: 'hermes',
+                platforms: [],
+                sessionsCount: 0,
+                heartbeatEnabled: false,
+            },
+        ]);
+        await runtime.stop();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('pi agent runtime routes projects through bundled pi ACP and coding agent', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
     try {
@@ -565,6 +606,45 @@ model = "deepseek-v4-flash"
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('runtime getLogs reads from disk after state is recreated', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-disk-logs-'));
+    try {
+        const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({ userDataPath });
+        state.pushLog('first persisted line');
+        state.pushLog('second persisted line');
+        const recreated = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({ userDataPath });
+        strict_1.default.deepEqual(recreated.getLogs(2).map((line) => line.replace(/^\S+\s+/, '')), [
+            'first persisted line',
+            'second persisted line',
+        ]);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('runtime getLogs fills from rotated log when current log has fewer lines', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-rotated-logs-'));
+    try {
+        const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({ userDataPath });
+        (0, node_fs_1.writeFileSync)(`${state.logPath}.1`, 'old-1\nold-2\nold-3\n', 'utf8');
+        (0, node_fs_1.writeFileSync)(state.logPath, 'new-1\n', 'utf8');
+        strict_1.default.deepEqual(state.getLogs(3), ['old-2', 'old-3', 'new-1']);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('runtime getLogs returns only the requested tail lines from disk', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-tail-logs-'));
+    try {
+        const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({ userDataPath });
+        (0, node_fs_1.writeFileSync)(state.logPath, Array.from({ length: 1000 }, (_, index) => `line-${index + 1}`).join('\n') + '\n', 'utf8');
+        strict_1.default.deepEqual(state.getLogs(4), ['line-997', 'line-998', 'line-999', 'line-1000']);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('controller logs are persisted to local-core.log', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-controller-logs-'));
     try {
@@ -739,7 +819,7 @@ name = "pi-workspace"
 [projects.agent]
 type = "pi"
 `);
-        strict_1.default.deepEqual(runtime.agentRuntimes.map((entry) => entry.agentType), ['localcore-acp', 'opencode', 'codex']);
+        strict_1.default.deepEqual(runtime.agentRuntimes.map((entry) => entry.agentType), ['localcore-acp', 'opencode', 'codex', 'hermes']);
         strict_1.default.equal(runtime.kernel.getCapabilitySnapshot().snapshot.agents.some((capability) => capability.agentType === 'claudecode'), false);
         strict_1.default.equal(runtime.kernel.getCapabilitySnapshot().snapshot.agents.some((capability) => capability.agentType === 'pi'), false);
         strict_1.default.deepEqual(await runtime.workspaceRouter.listWorkspaces(), []);

package/dist-electron/electron/workspace-task-store.test.js

@@ -198,7 +198,13 @@ const local_core_controller_js_1 = require("../services/local-ai-core/src/runtim
             model: '',
         });
         strict_1.default.equal(closeCount, 1);
-        strict_1.default.equal(capturedSessionNewParams[1]?._meta, undefined);
+        strict_1.default.deepEqual(capturedSessionNewParams[1]?._meta, {
+            claudeCode: {
+                emitRawSDKMessages: [
+                    { type: 'system', subtype: 'local_command_output' },
+                ],
+            },
+        });
     }
     finally {
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });

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

@@ -10,6 +10,8 @@ const local_core_acp_response_processor_js_1 = require("./local-core-acp-respons
 const local_core_acp_content_js_1 = require("./local-core-acp-content.js");
 const command_risk_js_1 = require("../security/command-risk.js");
 const local_core_slash_commands_js_1 = require("./local-core-slash-commands.js");
+const local_core_acp_progress_js_1 = require("./local-core-acp-progress.js");
+const index_js_1 = require("../agents/index.js");
 const ACP_PROMPT_TIMEOUT_MS = 15 * 60 * 1000;
 class LocalCoreAcpBackend {
     options;
@@ -199,8 +201,10 @@ class LocalCoreAcpBackend {
                 sessionKey: row.bridge_session_key,
             },
         });
-        void this.runPrompt(threadId, runId, row.bridge_session_key, config, message, options).catch((error) => {
-            this.options.log?.(`localcore-acp prompt failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+        setImmediate(() => {
+            void this.runPrompt(threadId, runId, row.bridge_session_key, config, message, options).catch((error) => {
+                this.options.log?.(`localcore-acp prompt failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
         });
         return { runId };
     }
@@ -300,15 +304,33 @@ class LocalCoreAcpBackend {
             session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config, {
                 permissionMode: options.permissionMode,
             });
+            const priorAssistantFinalMessages = this.options.store
+                .getThread(threadId, [])
+                .messages
+                .filter((entry) => entry.role === 'assistant' && entry.kind === 'final')
+                .map((entry) => entry.content);
+            const priorAssistantProgressMessages = this.options.store
+                .getThread(threadId, [])
+                .messages
+                .filter((entry) => entry.role === 'assistant' && entry.kind === 'progress')
+                .map((entry) => ({
+                kind: entry.bridgeKind,
+                content: entry.content,
+            }));
             session.currentRunId = runId;
             session.currentTurn = {
                 runId,
                 replyCtx: runId,
                 previewHandle: (0, node_crypto_1.randomUUID)(),
                 thoughtPreviewHandle: (0, node_crypto_1.randomUUID)(),
-                thoughtMessageId: `${runId}-thought`,
+                thoughtMessageId: `${runId}-thought-1`,
+                agentType: row.agent_type,
                 assistantText: '',
+                rawAssistantText: '',
+                priorAssistantFinalMessages,
+                priorAssistantProgressMessages,
                 thoughtText: '',
+                thoughtSequence: 1,
                 typingStarted: true,
                 previewStarted: false,
                 thoughtPreviewStarted: false,
@@ -319,6 +341,7 @@ class LocalCoreAcpBackend {
                 pendingToolCalls: {},
                 pendingToolCallOrder: [],
                 toolCallSequence: 0,
+                toolObservations: [],
                 permission: null,
             };
             const promptPromise = this.transport.request(session, 'session/prompt', {
@@ -332,9 +355,16 @@ class LocalCoreAcpBackend {
             if (!currentTurn || currentTurn.runId !== runId) {
                 return;
             }
+            this.turnCoordinator.closePendingThoughtSegment(session);
             this.turnCoordinator.flushPendingToolCall(session);
             if (currentTurn.assistantText) {
-                const processed = await this.responseProcessor.processAssistantResponse(threadId, currentTurn.assistantText);
+                const behavior = (0, index_js_1.resolveAgentAcpBehavior)(currentTurn.agentType);
+                const normalizedFinalAssistantText = behavior.normalizeFinalAssistantText({
+                    rawText: currentTurn.rawAssistantText || currentTurn.assistantText,
+                    priorAssistantMessages: currentTurn.priorAssistantFinalMessages || [],
+                });
+                const assistantText = (0, local_core_acp_progress_js_1.stripObservedToolTranscriptsFromAssistantText)(normalizedFinalAssistantText, currentTurn.toolObservations);
+                const processed = await this.responseProcessor.processAssistantResponse(threadId, assistantText);
                 if (processed.displayContent) {
                     this.options.store.appendMessage(threadId, 'assistant', processed.displayContent, 'final');
                     this.options.eventBus.emit({

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAssistantMessageChunk = applyAssistantMessageChunk;
 exports.applyThoughtChunk = applyThoughtChunk;
+exports.closeThoughtSegment = closeThoughtSegment;
 exports.registerPendingToolCall = registerPendingToolCall;
 exports.resolveToolCallForUpdate = resolveToolCallForUpdate;
 exports.resolveFallbackToolCall = resolveFallbackToolCall;
@@ -16,6 +17,8 @@ exports.isTerminalToolStatus = isTerminalToolStatus;
 exports.formatPlanProgress = formatPlanProgress;
 exports.extractToolCallKey = extractToolCallKey;
 exports.extractToolCallInput = extractToolCallInput;
+exports.recordToolObservation = recordToolObservation;
+exports.stripObservedToolTranscriptsFromAssistantText = stripObservedToolTranscriptsFromAssistantText;
 function applyAssistantMessageChunk(currentTurn, text) {
     if (!text) {
         return null;
@@ -41,8 +44,12 @@ function applyThoughtChunk(currentTurn, text) {
     if (!text) {
         return null;
     }
-    currentTurn.thoughtText = mergeStreamingText(currentTurn.thoughtText, text);
+    const projection = mergeThoughtSegment(currentTurn.thoughtText, text);
+    currentTurn.thoughtText = projection.fullText;
     const content = currentTurn.thoughtText.trim();
+    if (!content) {
+        return null;
+    }
     if (!currentTurn.thoughtPreviewStarted) {
         currentTurn.thoughtPreviewStarted = true;
         return {
@@ -61,23 +68,67 @@ function applyThoughtChunk(currentTurn, text) {
         bridgeKind: 'thought',
     };
 }
-function mergeStreamingText(current, next) {
+function closeThoughtSegment(currentTurn) {
+    const thoughtText = currentTurn.thoughtText || '';
+    if (!thoughtText.trim()) {
+        return;
+    }
+    const nextSequence = (currentTurn.thoughtSequence || 1) + 1;
+    const runId = currentTurn.runId || 'thought';
+    currentTurn.thoughtSequence = nextSequence;
+    currentTurn.thoughtText = '';
+    currentTurn.thoughtPreviewStarted = false;
+    currentTurn.thoughtMessageId = `${runId}-thought-${nextSequence}`;
+    currentTurn.thoughtPreviewHandle = `${runId}-thought-preview-${nextSequence}`;
+}
+function mergeThoughtSegment(current, next) {
     if (!current) {
-        return next;
+        return { fullText: next, segmentText: next };
     }
     if (next.startsWith(current)) {
-        return next;
+        return {
+            fullText: next,
+            segmentText: next.slice(current.length),
+        };
     }
     if (current.endsWith(next)) {
-        return current;
+        return {
+            fullText: current,
+            segmentText: '',
+        };
     }
     const maxOverlap = Math.min(current.length, next.length);
     for (let size = maxOverlap; size > 0; size -= 1) {
         if (current.endsWith(next.slice(0, size))) {
-            return current + next.slice(size);
+            const suffix = next.slice(size);
+            return {
+                fullText: current + suffix,
+                segmentText: suffix,
+            };
         }
     }
-    return current + next;
+    return {
+        fullText: appendThoughtPiece(current, next),
+        segmentText: next,
+    };
+}
+function appendThoughtPiece(current, next) {
+    if (!current.trim()) {
+        return next;
+    }
+    if (!next.trim()) {
+        return current;
+    }
+    if (/^[,.;:!?，。；：！？、）】》]/.test(next.trimStart())) {
+        return current.trimEnd() + next.trimStart();
+    }
+    if (/^[-/]/.test(next.trimStart()) || /[-/][A-Za-z0-9]*$/.test(current.trimEnd())) {
+        return current.trimEnd() + next.trimStart();
+    }
+    if (/\s$/.test(current) || /^\s/.test(next)) {
+        return current + next;
+    }
+    return `${current.trimEnd()} ${next.trimStart()}`;
 }
 function registerPendingToolCall(input) {
     const title = String(input.update.title || 'Running tool').trim();
@@ -203,3 +254,184 @@ function extractToolCallInput(update) {
     }
     return undefined;
 }
+function recordToolObservation(currentTurn, observation) {
+    const normalized = {
+        ...observation,
+        name: observation.name?.trim() || undefined,
+        title: observation.title?.trim() || undefined,
+        status: observation.status?.trim() || undefined,
+        outputText: observation.outputText?.trim() || undefined,
+    };
+    if (!normalized.name && !normalized.title && normalized.input === undefined && !normalized.outputText) {
+        return;
+    }
+    currentTurn.toolObservations = [
+        ...(currentTurn.toolObservations || []),
+        normalized,
+    ];
+}
+function stripObservedToolTranscriptsFromAssistantText(text, observations) {
+    let remaining = String(text || '');
+    const knownObservations = observations || [];
+    for (let guard = 0; guard < knownObservations.length; guard += 1) {
+        const stripped = stripOneObservedToolTranscriptPrefix(remaining, knownObservations);
+        if (stripped === remaining) {
+            break;
+        }
+        remaining = stripped;
+    }
+    return remaining.trim();
+}
+function stripOneObservedToolTranscriptPrefix(text, observations) {
+    const trimmedStart = text.replace(/^\s+/, '');
+    if (!trimmedStart) {
+        return text;
+    }
+    const matchingEvidence = observations
+        .map((observation) => createToolObservationEvidence(observation))
+        .find((evidence) => matchesObservedToolTranscriptPrefix(trimmedStart, evidence));
+    if (!matchingEvidence) {
+        return text;
+    }
+    const boundary = findToolTranscriptPrefixBoundary(trimmedStart, matchingEvidence);
+    if (boundary <= 0) {
+        return text;
+    }
+    return trimmedStart.slice(boundary);
+}
+function createToolObservationEvidence(observation) {
+    const serializedInput = serializeObservationValue(observation.input);
+    const serializedOutput = observation.outputText || '';
+    const structuredValues = collectStructuredStringValues(serializedOutput);
+    return {
+        toolNames: uniqueNonEmpty([
+            observation.name,
+            observation.title,
+        ].map((value) => normalizeEvidencePhrase(value || ''))),
+        urls: uniqueNonEmpty([
+            ...extractUrls(serializedInput),
+            ...extractUrls(serializedOutput),
+        ]),
+        phrases: uniqueNonEmpty([
+            ...structuredValues,
+            observation.title,
+            serializedInput.length <= 300 ? serializedInput : '',
+        ].map((value) => normalizeEvidencePhrase(value || '')).filter((value) => value.length >= 12)),
+    };
+}
+function matchesObservedToolTranscriptPrefix(text, evidence) {
+    const prefix = text.slice(0, 3000);
+    const normalizedPrefix = normalizeEvidencePhrase(prefix);
+    const hasToolName = evidence.toolNames.some((name) => name && normalizedPrefix.includes(name));
+    const urlMatches = evidence.urls.filter((url) => prefix.includes(url)).length;
+    const phraseMatches = evidence.phrases.filter((phrase) => normalizedPrefix.includes(phrase)).length;
+    if (hasToolName && (urlMatches > 0 || phraseMatches > 0)) {
+        return true;
+    }
+    return urlMatches > 0 && phraseMatches > 0;
+}
+function findToolTranscriptPrefixBoundary(text, evidence) {
+    const lines = text.split(/\n/);
+    const firstContentLine = lines.find((line) => line.trim());
+    if (!firstContentLine || !isTranscriptStartLine(firstContentLine, evidence)) {
+        return 0;
+    }
+    let offset = 0;
+    let seenEvidence = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] || '';
+        const lineWithNewlineLength = line.length + (index < lines.length - 1 ? 1 : 0);
+        if (lineContainsObservationEvidence(line, evidence)) {
+            seenEvidence = true;
+        }
+        if (seenEvidence && index > 0 && line.trim() && !isStructuredTranscriptLine(line, evidence)) {
+            return offset;
+        }
+        offset += lineWithNewlineLength;
+    }
+    return 0;
+}
+function isTranscriptStartLine(line, evidence) {
+    const trimmed = line.trim();
+    return lineContainsObservationEvidence(line, evidence) &&
+        (/^(```|\{|\[|\*\*[^*]+\*\*|#+\s)/.test(trimmed) || /^[A-Za-z0-9_.-]+:/.test(trimmed));
+}
+function isStructuredTranscriptLine(line, evidence) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return true;
+    }
+    if (lineContainsObservationEvidence(line, evidence)) {
+        return true;
+    }
+    return /^(```|\{|\}|\[|\]|".+":|\*\*[^*]+:\*\*|\*[^*]+\*|#+\s)/.test(trimmed) ||
+        /[:：]\s*$/.test(trimmed) ||
+        /[{}\[\]"]/g.test(trimmed) ||
+        /^[A-Za-z0-9_.-]+:/.test(trimmed);
+}
+function lineContainsObservationEvidence(line, evidence) {
+    const normalizedLine = normalizeEvidencePhrase(line);
+    return evidence.toolNames.some((name) => name && normalizedLine.includes(name)) ||
+        evidence.urls.some((url) => line.includes(url)) ||
+        evidence.phrases.some((phrase) => phrase && normalizedLine.includes(phrase));
+}
+function serializeObservationValue(value) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function collectStructuredStringValues(text) {
+    const values = [];
+    try {
+        collectStringValues(JSON.parse(text), values);
+    }
+    catch {
+        const matches = text.matchAll(/"(title|description|url|name|summary)"\s*:\s*"([^"]{12,})"/gi);
+        for (const match of matches) {
+            values.push(match[2] || '');
+        }
+    }
+    return values;
+}
+function collectStringValues(value, values) {
+    if (typeof value === 'string') {
+        values.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectStringValues(item, values);
+        }
+        return;
+    }
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    for (const entry of Object.values(value)) {
+        collectStringValues(entry, values);
+    }
+}
+function extractUrls(text) {
+    return [...text.matchAll(/https?:\/\/[^\s"'`<>),\]}]+/g)]
+        .map((match) => match[0])
+        .filter(Boolean);
+}
+function normalizeEvidencePhrase(value) {
+    return String(value || '')
+        .replace(/\\[nrt]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function uniqueNonEmpty(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

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

@@ -194,14 +194,18 @@ class LocalCoreAcpSessionCoordinator {
     }
     buildSessionMeta(threadId, permissionModeOverride = '') {
         const mode = this.resolveLaunchPermissionMode(threadId, permissionModeOverride);
-        if (!mode) {
-            return undefined;
-        }
         return {
             claudeCode: {
-                options: {
-                    permissionMode: mode,
-                },
+                emitRawSDKMessages: [
+                    { type: 'system', subtype: 'local_command_output' },
+                ],
+                ...(mode
+                    ? {
+                        options: {
+                            permissionMode: mode,
+                        },
+                    }
+                    : {}),
             },
         };
     }

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

@@ -35,6 +35,7 @@ class LocalCoreAcpTransport {
             loadReplayMode: false,
             pendingPermissionByRun: new Map(),
             schedulerJobCreatedByRun: new Map(),
+            pendingRawAssistantProgressChunks: [],
             closed: false,
             closeReason: null,
             promptPromise: null,