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

package/dist/runtime-host-capability-provider-command.js

@@ -22,7 +22,7 @@ import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { createCredentialMcpOAuthStorage, formatMcpDiagnosticText, McpClientManager, } from '@maka/mcp';
 import { createFileCredentialStore } from '@maka/storage/credential-store';
-import { normalizeMcpConfig } from '@maka/storage/mcp-config-store';
+import { normalizeMcpConfig, subscribeMcpConfigFileChanges } from '@maka/storage/mcp-config-store';
 import { connectRemoteRuntimeHost, loadOrCreateRuntimeHostClientInstanceId, remoteRuntimeHostUnavailableError, RuntimeHostPermanentReconnectError, startRuntimeHostCapabilityProviderService, } from '@maka/runtime-host/client';
 import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_COMPATIBILITY_EPOCH, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { runRuntimeHostProcessLifecycle } from '@maka/runtime-host/server';
@@ -39,11 +39,14 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
     const credential = process.env[credentialEnv];
     if (!credential)
         throw new Error(`Runtime Host access credential is missing from ${credentialEnv}`);
-    const configText = await readFile(configPath, 'utf8');
-    if (Buffer.byteLength(configText, 'utf8') > MAX_MCP_CONFIG_BYTES) {
-        throw new Error('MCP config exceeds 1 MiB');
-    }
-    const config = normalizeMcpConfig(JSON.parse(configText));
+    const readConfig = async () => {
+        const configText = await readFile(configPath, 'utf8');
+        if (Buffer.byteLength(configText, 'utf8') > MAX_MCP_CONFIG_BYTES) {
+            throw new Error('MCP config exceeds 1 MiB');
+        }
+        return normalizeMcpConfig(JSON.parse(configText));
+    };
+    const config = await readConfig();
     const clientInstanceId = await loadOrCreateRuntimeHostClientInstanceId(identityPath);
     const manager = new McpClientManager({
         clientName: 'maka-capability-provider',
@@ -55,6 +58,21 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
         oauthStorage: createCredentialMcpOAuthStorage(createFileCredentialStore(dirname(configPath))),
     });
     await manager.sync(config);
+    // Desktop and the TUI edit this file while the provider runs. One change is
+    // read and applied at a time, so an older read never lands last.
+    let following = Promise.resolve();
+    const stopFollowing = subscribeMcpConfigFileChanges(configPath, (error) => {
+        if (error) {
+            process.stderr.write(`MCP config is no longer followed: ${error.message}\n`);
+            return;
+        }
+        following = following
+            .then(async () => manager.sync(await readConfig()))
+            .catch((failure) => {
+            const message = failure instanceof Error ? failure.message : String(failure);
+            process.stderr.write(`MCP config change was not applied: ${message}\n`);
+        });
+    });
     let service;
     let publishedRevision = manager.toolSnapshot().revision;
     const disposeChanges = manager.onChange(() => {
@@ -100,6 +118,7 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
     }
     finally {
         clearInterval(reconnectTimer);
+        stopFollowing();
         disposeChanges();
         await service?.close().catch(() => undefined);
         await manager.close();

package/dist/tui-mcp-control.js

@@ -17,10 +17,10 @@
  * 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';
@@ -43,6 +43,7 @@ class TuiMcpControllerImpl {
     #listeners = new Set();
     #disposeManagerChange;
     #disposeConnectionAvailability;
+    #disposeConfigChanges;
     #initialization;
     #availability = { kind: 'unavailable' };
     #closed = false;
@@ -112,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() {
@@ -176,6 +188,7 @@ class TuiMcpControllerImpl {
         this.#closed = true;
         this.#disposeManagerChange();
         this.#disposeConnectionAvailability();
+        this.#disposeConfigChanges();
         this.#listeners.clear();
         this.#preparedImport = undefined;
         const publicationClosing = this.#publication.close().catch(() => undefined);
@@ -264,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.
@@ -336,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();

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';
+}