maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

package/dist/tui-mcp-control.js

@@ -17,11 +17,12 @@
  * under the License.
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { MCP_CONFIG_VERSION, mcpConfigChangeRetiresCredentials, resolveMcpProtocolPreference, } from '@maka/core/mcp';
+import { MCP_CONFIG_VERSION, resolveMcpProtocolPreference, } from '@maka/core/mcp';
 import { createCredentialMcpOAuthStorage, McpClientManager } from '@maka/mcp';
 import { createFileCredentialStore } from '@maka/storage/credential-store';
-import { AtomicFileWriteCommitUnknownError, createMcpConfigStore, assertMcpEndpointPolicyOnChanges, McpConfigSourceError, normalizeMcpConfig, normalizeMcpImport, } from '@maka/storage/mcp-config-store';
+import { AtomicFileWriteCommitUnknownError, createMcpConfigStore, updateMcpConfiguration, McpConfigurationValidationError, McpConfigSourceError, normalizeMcpConfig, normalizeMcpImport, } from '@maka/storage/mcp-config-store';
 import { createMcpCapabilityProvider } from './mcp-capability-provider.js';
+import { McpCapabilityPublication } from './mcp-capability-publication.js';
 const RUNTIME_HOST_CREDENTIAL_ENV = 'MAKA_RUNTIME_HOST_ACCESS_CREDENTIAL';
 export function createTuiMcpController(input, overrides = {}) {
     const manager = overrides.manager ??
@@ -42,6 +43,7 @@ class TuiMcpControllerImpl {
     #listeners = new Set();
     #disposeManagerChange;
     #disposeConnectionAvailability;
+    #disposeConfigChanges;
     #initialization;
     #availability = { kind: 'unavailable' };
     #closed = false;
@@ -49,9 +51,7 @@ class TuiMcpControllerImpl {
     #preparedImport;
     #actionLane = Promise.resolve();
     #publicationSuppressed = false;
-    #publicationRequested = false;
-    #publicationTask;
-    #published;
+    #publication;
     #snapshot = freezeSnapshot({
         initialization: 'loading',
         configuration: 'synchronizing',
@@ -67,6 +67,24 @@ class TuiMcpControllerImpl {
             ...this.#snapshot,
             canManagePublicationCredential: Boolean(connection.setCredential && connection.removeCredential),
         });
+        this.#publication = new McpCapabilityPublication({
+            connectionIdentity: () => this.#availability.kind === 'connected'
+                ? connectionIdentity(this.#availability)
+                : undefined,
+            revision: () => this.#deps.manager.toolSnapshot().revision,
+            createProvider: () => this.#deps.createProvider(this.#deps.manager),
+            replace: (provider) => this.#connection.replaceClientCapabilities(provider),
+            unregister: () => this.#connection.unregisterClientCapabilities(),
+            onState: (state) => {
+                this.#updateSnapshot({
+                    publication: state === 'unavailable'
+                        ? this.#availability.kind === 'unavailable'
+                            ? (this.#availability.reason ?? 'host_unavailable')
+                            : 'waiting'
+                        : state,
+                });
+            },
+        });
         this.#disposeManagerChange = deps.manager.onChange(() => {
             try {
                 this.#refreshManagerSnapshot();
@@ -81,7 +99,7 @@ class TuiMcpControllerImpl {
         this.#disposeConnectionAvailability = connection.subscribeConnectionAvailability((availability) => {
             this.#availability = availability;
             if (availability.kind === 'unavailable') {
-                this.#published = undefined;
+                this.#publication.invalidate();
                 this.#updateSnapshot({
                     publication: availability.reason ?? 'host_unavailable',
                     ...(availability.reason === 'provider_conflict'
@@ -95,6 +113,17 @@ class TuiMcpControllerImpl {
                     this.#requestPublication();
             }
         });
+        // Desktop edits the same file. A change during startup waits for it
+        // rather than being dropped, since startup may have read the file first.
+        // Failing to follow leaves the TUI's own edits working, so it stays quiet
+        // rather than print over the screen.
+        this.#disposeConfigChanges = deps.configStore.subscribeChanges((error) => {
+            if (error)
+                return;
+            void this.#initialization
+                .then(() => this.#serializeAction(() => this.#followConfigChange()))
+                .catch(() => undefined);
+        });
         this.#initialization = this.#initialize();
     }
     snapshot() {
@@ -159,17 +188,14 @@ class TuiMcpControllerImpl {
         this.#closed = true;
         this.#disposeManagerChange();
         this.#disposeConnectionAvailability();
+        this.#disposeConfigChanges();
         this.#listeners.clear();
         this.#preparedImport = undefined;
-        this.#publicationRequested = false;
+        const publicationClosing = this.#publication.close().catch(() => undefined);
         const managerClosing = this.#deps.manager.close();
         await this.#actionLane.catch(() => undefined);
         this.#config = undefined;
-        await this.#publicationTask?.catch(() => undefined);
-        if (this.#availability.kind === 'connected') {
-            await this.#connection.unregisterClientCapabilities().catch(() => undefined);
-        }
-        this.#published = undefined;
+        await publicationClosing;
         await this.#connection.closePublication?.().catch(() => undefined);
         await managerClosing;
         await this.#initialization.catch(() => undefined);
@@ -251,44 +277,32 @@ class TuiMcpControllerImpl {
     async #commitMutation(action) {
         let committed;
         try {
-            committed = await this.#deps.configStore.transform(async (current) => {
-                if (this.#closed) {
+            committed = await updateMcpConfiguration(this.#deps.configStore, (current) => {
+                if (this.#closed)
                     throw new TuiMcpMutationError({ status: 'failed', reason: 'closed' });
-                }
                 const prepared = this.#prepareMutation(current, action);
                 if ('status' in prepared)
                     throw new TuiMcpMutationError(prepared);
-                const { next } = prepared;
+                return prepared.next;
+            }, async (serverId, previous) => {
                 try {
-                    assertMcpEndpointPolicyOnChanges(current, next);
+                    await this.#deps.manager.forgetServerCredentials(serverId, previous);
                 }
                 catch {
-                    throw new TuiMcpMutationError({ status: 'failed', reason: 'invalid-config' });
-                }
-                try {
-                    for (const [serverId, previous] of Object.entries(current.mcpServers)) {
-                        if (!mcpConfigChangeRetiresCredentials(previous, next.mcpServers[serverId]))
-                            continue;
-                        await this.#deps.manager.forgetServerCredentials(serverId, previous);
-                        if (this.#closed) {
-                            throw new TuiMcpMutationError({ status: 'failed', reason: 'closed' });
-                        }
-                    }
-                }
-                catch (error) {
-                    if (error instanceof TuiMcpMutationError)
-                        throw error;
                     throw new TuiMcpMutationError({
                         status: 'failed',
                         reason: 'credential-cleanup-failed',
                     });
                 }
-                return next;
+                if (this.#closed)
+                    throw new TuiMcpMutationError({ status: 'failed', reason: 'closed' });
             });
         }
         catch (error) {
             if (error instanceof TuiMcpMutationError)
                 return error.result;
+            if (error instanceof McpConfigurationValidationError)
+                return { status: 'failed', reason: 'invalid-config' };
             if (error instanceof AtomicFileWriteCommitUnknownError) {
                 // The transform has already published, including any credential
                 // retirement. Reload its authority; never replay those effects.
@@ -323,12 +337,24 @@ class TuiMcpControllerImpl {
             }
             return { status: 'failed', reason: 'persist-failed' };
         }
+        this.#preparedImport = undefined;
         return (await this.#synchronizeCommittedConfig(committed)).result;
     }
+    async #followConfigChange() {
+        if (this.#closed)
+            return;
+        if (this.#snapshot.initialization === 'error')
+            return this.#initialize();
+        const latest = await this.#deps.configStore.get();
+        // An import preview survives: its commit re-checks each server it replaces.
+        if (this.#snapshot.configuration !== 'ready' ||
+            JSON.stringify(latest) !== JSON.stringify(this.#config)) {
+            await this.#synchronizeCommittedConfig(latest);
+        }
+    }
     async #synchronizeCommittedConfig(committed) {
         if (this.#closed)
             return { result: { status: 'failed', reason: 'closed' } };
-        this.#preparedImport = undefined;
         this.#config = cloneConfig(committed);
         this.#updateSnapshot({ configuration: 'synchronizing' });
         this.#refreshManagerSnapshot();
@@ -400,9 +426,10 @@ class TuiMcpControllerImpl {
         }
     }
     async #settlePublication() {
-        this.#requestPublication();
-        while (!this.#closed && (this.#publicationTask || this.#publicationRequested)) {
-            await this.#publicationTask?.catch(() => undefined);
+        if (!this.#closed &&
+            this.#snapshot.initialization === 'ready' &&
+            !this.#publicationSuppressed) {
+            await this.#publication.settle();
         }
         if (this.#snapshot.publication === 'error' ||
             this.#snapshot.publication === 'credential_rejected' ||
@@ -436,74 +463,9 @@ class TuiMcpControllerImpl {
         this.#notify();
     }
     #requestPublication() {
-        if (this.#closed) {
-            this.#publicationRequested = false;
+        if (this.#closed || this.#snapshot.initialization !== 'ready' || this.#publicationSuppressed)
             return;
-        }
-        if (this.#snapshot.initialization !== 'ready' || this.#publicationSuppressed)
-            return;
-        this.#publicationRequested = true;
-        if (this.#publicationTask)
-            return;
-        this.#publicationTask = this.#runPublicationQueue().finally(() => {
-            this.#publicationTask = undefined;
-            if (this.#publicationRequested)
-                this.#requestPublication();
-        });
-    }
-    async #runPublicationQueue() {
-        while (this.#publicationRequested && !this.#closed) {
-            this.#publicationRequested = false;
-            await this.#publishCurrentSnapshot();
-        }
-    }
-    async #publishCurrentSnapshot() {
-        const availability = this.#availability;
-        if (availability.kind !== 'connected') {
-            this.#updateSnapshot({ publication: availability.reason ?? 'host_unavailable' });
-            return;
-        }
-        const identity = connectionIdentity(availability);
-        const revision = this.#deps.manager.toolSnapshot().revision;
-        if (this.#published?.identity === identity && this.#published.revision === revision) {
-            this.#updateSnapshot({
-                publication: this.#snapshot.toolCount === 0 ? 'not_published' : 'published',
-            });
-            return;
-        }
-        let provider;
-        this.#updateSnapshot({ publication: 'publishing' });
-        try {
-            provider = this.#deps.createProvider(this.#deps.manager);
-            if (provider) {
-                await this.#connection.replaceClientCapabilities(provider);
-            }
-            else if (this.#published?.identity === identity && this.#published.registered) {
-                await this.#connection.unregisterClientCapabilities();
-            }
-        }
-        catch {
-            await closeProvider(provider);
-            if (this.#isCurrent(identity, revision)) {
-                this.#updateSnapshot({ publication: 'error' });
-            }
-            else {
-                this.#requestPublication();
-            }
-            return;
-        }
-        if (!this.#isCurrent(identity, revision)) {
-            this.#requestPublication();
-            return;
-        }
-        this.#published = { identity, revision, registered: provider !== undefined };
-        this.#updateSnapshot({ publication: provider ? 'published' : 'not_published' });
-    }
-    #isCurrent(identity, revision) {
-        return (!this.#closed &&
-            this.#availability.kind === 'connected' &&
-            connectionIdentity(this.#availability) === identity &&
-            this.#deps.manager.toolSnapshot().revision === revision);
+        this.#publication.request();
     }
     #updateSnapshot(update) {
         this.#snapshot = freezeSnapshot({ ...this.#snapshot, ...update });
@@ -548,14 +510,6 @@ function freezeSnapshot(snapshot) {
 function connectionIdentity(availability) {
     return `${availability.hostEpoch}\0${availability.connectionId}`;
 }
-async function closeProvider(provider) {
-    try {
-        await provider?.close?.();
-    }
-    catch {
-        // A rejected provider never crossed into Host ownership.
-    }
-}
 function cloneConfig(config) {
     return structuredClone(config);
 }

package/node_modules/@maka/acp-executor-plugin/dist/acp-errors.js

@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export class AcpRuntimeError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AcpRuntimeError';
+    }
+}

package/node_modules/@maka/acp-executor-plugin/dist/acp-filesystem.js

@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { constants } from 'node:fs';
+import { lstat, open, realpath, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+const MAX_TEXT_FILE_BYTES = 8 * 1024 * 1024;
+export async function readWorkspaceTextFile(cwd, path, line, limit) {
+    if (line != null && (!Number.isSafeInteger(line) || line < 1))
+        throw new Error('ACP file line must be a positive integer');
+    if (limit != null && (!Number.isSafeInteger(limit) || limit < 0))
+        throw new Error('ACP file limit must be a non-negative integer');
+    const file = await openWorkspaceFile(cwd, path, false);
+    try {
+        const info = await file.stat();
+        if (info.size > MAX_TEXT_FILE_BYTES)
+            throw new Error('ACP text file is too large');
+        const text = await file.readFile('utf8');
+        const start = line == null ? 0 : line - 1;
+        return line != null || limit != null
+            ? text
+                .split('\n')
+                .slice(start, limit == null ? undefined : start + limit)
+                .join('\n')
+            : text;
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function writeWorkspaceTextFile(cwd, path, content) {
+    if (Buffer.byteLength(content) > MAX_TEXT_FILE_BYTES)
+        throw new Error('ACP text file is too large');
+    const file = await openWorkspaceFile(cwd, path, true);
+    try {
+        // Validation happens against this exact open file descriptor before any
+        // existing content is truncated, so later path swaps cannot redirect data.
+        await file.truncate(0);
+        await file.writeFile(content, 'utf8');
+    }
+    finally {
+        await file.close();
+    }
+}
+async function openWorkspaceFile(cwd, path, forWrite) {
+    if (!isAbsolute(path))
+        throw new Error('ACP file path must be absolute');
+    const root = await realpath(cwd);
+    const candidate = resolve(path);
+    if (forWrite) {
+        const parent = await realpath(dirname(candidate));
+        assertContained(root, parent);
+        const entry = await lstat(candidate).catch((error) => {
+            if (error.code !== 'ENOENT')
+                throw error;
+            return undefined;
+        });
+        if (entry?.isSymbolicLink())
+            throw new Error('ACP file path could not be resolved');
+    }
+    const flags = forWrite
+        ? constants.O_WRONLY | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0)
+        : constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
+    const file = await open(candidate, flags, 0o600);
+    try {
+        const opened = await file.stat();
+        if (!opened.isFile())
+            throw new Error('ACP file path is not a regular file');
+        // Resolve and compare after opening. If the path or an ancestor changed
+        // between lookup and open, either containment or file identity no longer
+        // matches. Operations after this point use only the verified descriptor.
+        const canonical = await realpath(candidate);
+        assertContained(root, canonical);
+        const current = await stat(canonical);
+        if (opened.dev !== current.dev || opened.ino !== current.ino)
+            throw new Error('ACP file path changed during validation');
+        return file;
+    }
+    catch (error) {
+        await file.close();
+        throw error;
+    }
+}
+function assertContained(root, candidate) {
+    const relation = relative(root, candidate);
+    if (relation === '..' || relation.startsWith('../') || isAbsolute(relation))
+        throw new Error('ACP file path leaves the workspace');
+}

package/node_modules/@maka/acp-executor-plugin/dist/acp-process.js

@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import { setTimeout as delay } from 'node:timers/promises';
+import { client, ndJsonStream, } from '@agentclientprotocol/sdk';
+import { terminateProcessTree } from '@maka/runtime/process-tree-terminator';
+import { AcpRuntimeError } from './acp-errors.js';
+const PROCESS_EXIT_TIMEOUT_MS = 2_000;
+export function createAcpConnection(input) {
+    let child;
+    try {
+        child = spawn(input.executable, [...(input.args ?? [])], {
+            cwd: input.cwd,
+            env: input.env,
+            stdio: 'pipe',
+            detached: true,
+            shell: false,
+        });
+    }
+    catch {
+        throw new AcpRuntimeError('ACP executable is unavailable', 'acp_executable_unavailable');
+    }
+    let disposing = false;
+    let disposed = false;
+    let disposal;
+    let rejectFailure;
+    const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+    });
+    void failed.catch(() => undefined);
+    const fail = () => {
+        if (!disposing)
+            rejectFailure(new Error('ACP connection failed'));
+    };
+    child.once('error', fail);
+    child.stdin.once('error', fail);
+    child.stderr.once('error', fail);
+    child.stderr.on('data', () => undefined);
+    child.once('close', fail);
+    const app = client({ name: input.clientName });
+    input.configureClient(app);
+    const connection = app.connect(ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
+    void connection.closed.then(fail, fail);
+    return {
+        connection,
+        failed,
+        dispose() {
+            if (disposed)
+                return Promise.resolve();
+            if (disposal)
+                return disposal;
+            disposing = true;
+            disposal = terminate(child, connection).then(() => {
+                disposed = true;
+            }, (error) => {
+                disposal = undefined;
+                throw error;
+            });
+            return disposal;
+        },
+    };
+}
+async function terminate(child, connection) {
+    const pid = child.pid;
+    const alive = () => {
+        if (!pid)
+            return false;
+        if (process.platform === 'win32')
+            return child.exitCode === null && child.signalCode === null;
+        try {
+            process.kill(-pid, 0);
+            return true;
+        }
+        catch (error) {
+            return error.code !== 'ESRCH';
+        }
+    };
+    try {
+        if (pid) {
+            await terminateProcessTree({ pid, signal: 'SIGTERM', fallback: () => child.kill('SIGTERM') });
+            for (let elapsed = 0; elapsed < PROCESS_EXIT_TIMEOUT_MS && alive(); elapsed += 50)
+                await delay(50);
+            if (alive()) {
+                await terminateProcessTree({
+                    pid,
+                    signal: 'SIGKILL',
+                    fallback: () => child.kill('SIGKILL'),
+                });
+                for (let elapsed = 0; elapsed < PROCESS_EXIT_TIMEOUT_MS && alive(); elapsed += 50)
+                    await delay(50);
+            }
+            if (alive())
+                throw new Error('ACP process cleanup failed');
+        }
+    }
+    finally {
+        connection.close();
+        child.stdin.destroy();
+        child.stdout.destroy();
+        child.stderr.destroy();
+    }
+}

package/node_modules/@maka/acp-executor-plugin/dist/acp-projection.js

@@ -0,0 +1,146 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+const MAX_EVENT_TEXT = 8_192;
+const MAX_TOOL_RESULT_DIFF = 1024 * 1024;
+export function promptText(request) {
+    const sections = [request.text];
+    if (request.instructions)
+        sections.push(`Agent instructions:\n${request.instructions}`);
+    for (const quote of request.quotes ?? [])
+        sections.push(`Quoted context:\n${quote.text}`);
+    for (const reference of request.directoryReferences ?? [])
+        sections.push(`Project directory reference: ${reference.path}`);
+    return sections.filter(Boolean).join('\n\n');
+}
+export function emitText(context, type, text) {
+    const safeText = text.replaceAll('\r', '');
+    for (let offset = 0; offset < safeText.length; offset += MAX_EVENT_TEXT) {
+        const chunk = safeText.slice(offset, offset + MAX_EVENT_TEXT);
+        context.emit({ type, text: chunk });
+    }
+}
+export function emitToolOutput(context, toolCallId, text) {
+    const safeText = text.replaceAll('\r', '');
+    for (let offset = 0; offset < safeText.length; offset += MAX_EVENT_TEXT) {
+        context.emit({
+            type: 'tool_output_delta',
+            toolCallId,
+            text: safeText.slice(offset, offset + MAX_EVENT_TEXT),
+        });
+    }
+}
+export function projectToolResult(content, rawOutput) {
+    const diffs = content.flatMap((item) => item.type === 'diff'
+        ? [
+            {
+                path: item.path,
+                diff: createWholeFileDiff(item.path, item.oldText ?? '', item.newText ?? ''),
+            },
+        ]
+        : []);
+    const combinedDiff = diffs.map(({ diff }) => diff).join('');
+    if (diffs.length && diffs.length <= 64 && combinedDiff.length <= MAX_TOOL_RESULT_DIFF)
+        return {
+            kind: 'file_diff',
+            paths: diffs.map(({ path }) => path),
+            diff: combinedDiff,
+        };
+    if (diffs.length)
+        return {
+            kind: 'text',
+            text: boundedText(`${diffs.map(({ path }) => `Updated ${path}`).join('\n')}\nDiff omitted because it exceeds the executor event limit.`),
+        };
+    return { kind: 'text', text: boundedText(summarizeToolResult(content, rawOutput)) };
+}
+function createWholeFileDiff(path, oldText, newText) {
+    const oldFile = diffLines(oldText);
+    const newFile = diffLines(newText);
+    const oldLines = oldFile.lines;
+    const newLines = newFile.lines;
+    return ([
+        `--- a/${path}`,
+        `+++ b/${path}`,
+        `@@ -${oldLines.length ? 1 : 0},${oldLines.length} +${newLines.length ? 1 : 0},${newLines.length} @@`,
+        ...diffSide(oldLines, '-', oldFile.endsWithNewline),
+        ...diffSide(newLines, '+', newFile.endsWithNewline),
+    ].join('\n') + '\n');
+}
+function diffLines(text) {
+    const normalized = text.replaceAll('\r', '');
+    if (!normalized)
+        return { lines: [], endsWithNewline: true };
+    const endsWithNewline = normalized.endsWith('\n');
+    const lines = normalized.split('\n');
+    if (endsWithNewline)
+        lines.pop();
+    return { lines, endsWithNewline };
+}
+function diffSide(lines, prefix, endsWithNewline) {
+    return lines.flatMap((line, index) => [
+        `${prefix}${line}`,
+        ...(index === lines.length - 1 && !endsWithNewline ? ['\'] : []),
+    ]);
+}
+export function summarizeToolContent(content) {
+    return content
+        .map((item) => {
+        if (item.type === 'diff')
+            return `Updated ${item.path}`;
+        if (item.type === 'terminal')
+            return item.terminalId ? `Terminal ${item.terminalId}` : '';
+        return item.content.type === 'text' ? item.content.text : '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function summarizeToolResult(content, rawOutput) {
+    const summary = summarizeToolContent(content);
+    if (summary)
+        return summary;
+    if (rawOutput === undefined)
+        return '';
+    try {
+        return JSON.stringify(rawOutput);
+    }
+    catch {
+        return 'External tool completed';
+    }
+}
+export function boundedText(value) {
+    const safe = value.replace(/[\0\r]/gu, '');
+    return safe.length <= MAX_EVENT_TEXT ? safe : `${safe.slice(0, MAX_EVENT_TEXT - 1)}…`;
+}
+export function toolName(value) {
+    return value.replace(/[\0\r\n]/gu, '').slice(0, 256) || 'external_tool';
+}
+export function activityKind(kind) {
+    if (kind === 'read')
+        return 'read';
+    if (kind === 'edit' || kind === 'delete' || kind === 'move')
+        return 'edit';
+    if (kind === 'search')
+        return 'search';
+    if (kind === 'fetch')
+        return 'webfetch';
+    if (kind === 'execute')
+        return 'command';
+    if (kind === 'think')
+        return 'explore';
+    return 'tool';
+}