maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/web/infra/index.js

@@ -52,6 +52,19 @@ function collectASequenceOfCodePointsFast (char, input, position) {
 }
 
 const ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g // eslint-disable-line no-control-regex
+const nonASCIIRegex = /[^\x00-\x7F]/ // eslint-disable-line no-control-regex
+
+/**
+ * @param {string} str
+ * @returns {string}
+ *
+ * @see https://infra.spec.whatwg.org/#ascii-lowercase
+ */
+function asciiLowercase (str) {
+  return nonASCIIRegex.test(str)
+    ? str.replace(/[A-Z]+/g, (upper) => upper.toLowerCase())
+    : str.toLowerCase()
+}
 
 /**
  * @param {string} data
@@ -216,6 +229,7 @@ function serializeJavascriptValueToJSONString (value) {
 }
 
 module.exports = {
+  asciiLowercase,
   collectASequenceOfCodePoints,
   collectASequenceOfCodePointsFast,
   forgivingBase64,

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/web/subresource-integrity/subresource-integrity.js

@@ -2,6 +2,7 @@
 
 const assert = require('node:assert')
 const { runtimeFeatures } = require('../../util/runtime-features.js')
+const { asciiLowercase } = require('../infra/index.js')
 
 /**
  * @typedef {object} Metadata
@@ -66,14 +67,12 @@ const getSRIHashAlgorithmIndex = /** @type {GetSRIHashAlgorithmIndex} */ (Map.pr
 
 /**
  * @typedef IsValidSRIHashAlgorithm
+ * @see https://w3c.github.io/webappsec-subresource-integrity/#valid-sri-hash-algorithm-token
  * @type {(algorithm: string) => algorithm is SRIHashAlgorithm}
  * @param {*} algorithm
  * @returns {algorithm is SRIHashAlgorithm}
  */
-
-const isValidSRIHashAlgorithm = /** @type {IsValidSRIHashAlgorithm} */ (
-  Map.prototype.has.bind(validSRIHashAlgorithmTokenSet)
-)
+const isValidSRIHashAlgorithm = (algorithm) => validSRIHashAlgorithmTokenSet.has(asciiLowercase(algorithm))
 
 /**
  * @param {Uint8Array} bytes
@@ -229,7 +228,8 @@ function parseMetadata (metadata) {
     // 8. Let metadata be the ordered map
     // «["alg" → algorithm, "val" → base64-value]».
     const metadata = {
-      alg: algorithm,
+      // Possible spec bug?
+      alg: asciiLowercase(algorithm),
       val: base64Value
     }
 

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/web/websocket/receiver.js

@@ -244,6 +244,19 @@ class ByteParser extends Writable {
         if (isControlFrame(this.#info.opcode)) {
           this.#loop = this.parseControlFrame(body)
           this.#state = parserStates.INFO
+
+          // If the automatic PONG/CLOSE reply filled the socket's write buffer,
+          // stop parsing and resume on drain so a PING flood cannot grow the
+          // outbound queue without bound.
+          if (this.#loop && this.#handler.socket.writableNeedDrain) {
+            this.#loop = false
+            this.#handler.socket.once('drain', () => {
+              if (this.destroyed) return
+              this.#loop = true
+              this.run(callback)
+            })
+            return
+          }
         } else {
           if (!this.#info.compressed) {
             if (!this.writeFragments(body)) {

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.30.0",
+  "version": "7.30.1",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

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

@@ -0,0 +1,87 @@
+/*
+ * 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 { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { access, realpath, stat } from 'node:fs/promises';
+import { normalizeCatalogEntry } from '@maka/core/executor-catalog';
+// Covers both the stored shape and the semantics of the derived catalog.
+// Bump when AcpExecutor.#catalogEntry, catalog normalization, or any adapter's
+// displayName/describeModels changes persisted labels, groups, provider types,
+// defaults, or capabilities. Configuration and executable fingerprints cannot
+// detect those code-only changes. A mismatch forces one neutral discovery.
+const CATALOG_SNAPSHOT_VERSION = 2;
+export function createAcpCatalogStore(persistence, executorId, config, launch) {
+    // Persist only a digest, never configuration values or credentials. Do not
+    // fingerprint the inherited process environment: it includes per-launch
+    // values and would make an otherwise unchanged restart miss the cache.
+    const configuration = JSON.stringify({
+        executorId,
+        config,
+        executable: launch.executable,
+        requiredExecutables: launch.requiredExecutables,
+        args: launch.args,
+        cwd: launch.cwd,
+        initialConfig: launch.initialConfig,
+        platform: process.platform,
+        arch: process.arch,
+    }, (_key, value) => value && typeof value === 'object' && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)))
+        : value);
+    const fingerprint = async () => {
+        const files = await Promise.all([launch.executable, ...(launch.requiredExecutables ?? [])].map(async (path) => {
+            const resolved = await realpath(path);
+            await access(resolved, constants.X_OK);
+            const file = await stat(resolved);
+            if (!file.isFile())
+                throw new Error('ACP executable is not a file');
+            return { path: resolved, size: file.size, mtime: file.mtimeMs, ctime: file.ctimeMs };
+        }));
+        // Check current metadata when loading or persisting a neutral probe, not on cached reads.
+        return createHash('sha256').update(configuration).update(JSON.stringify(files)).digest('hex');
+    };
+    const { storage, key } = persistence;
+    return {
+        async load() {
+            const value = (await storage.get(key)).value;
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                return;
+            const record = value;
+            // Version 1 could contain project-specific Session models. Re-probe once
+            // rather than allowing those candidates to survive an upgrade indefinitely.
+            if (record.version !== CATALOG_SNAPSHOT_VERSION || record.binding !== (await fingerprint()))
+                return;
+            const entry = normalizeCatalogEntry(record.entry, executorId);
+            return entry.readiness === 'ready' ? entry : undefined;
+        },
+        async save(entry) {
+            if (!entry) {
+                await storage.delete(key);
+                return;
+            }
+            const normalized = normalizeCatalogEntry(entry, executorId);
+            if (normalized.readiness !== 'ready')
+                return;
+            await storage.set(key, {
+                version: CATALOG_SNAPSHOT_VERSION,
+                binding: await fingerprint(),
+                entry: normalized,
+            });
+        },
+    };
+}

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

@@ -16,37 +16,49 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-const CATALOG_TTL_MS = 60_000;
 const PROBE_TIMEOUT_MS = 30_000;
-/** Instance-scoped candidates. Only a retained task Session owns workspace configuration. */
+const RETRY_COOLDOWN_MS = 60_000;
+/** Public candidates come only from neutral discovery; task capabilities remain Session-owned. */
 export class AcpCatalog {
     admission;
     probe;
     unavailable;
+    drain;
+    store;
     #cached;
     #pending;
     #tail;
-    #operations = new Set();
     #revision = 0;
     #disposed = false;
-    constructor(admission, probe, unavailable) {
+    #hydration;
+    #writes = Promise.resolve();
+    #failure;
+    constructor(admission, probe, unavailable, drain = async () => { }, store) {
         this.admission = admission;
         this.probe = probe;
         this.unavailable = unavailable;
+        this.drain = drain;
+        this.store = store;
     }
     async get(signal, refresh = false) {
         signal.throwIfAborted();
         if (this.#disposed)
             return this.unavailable();
-        if (refresh)
-            this.invalidate();
+        await waitForSignal(this.#hydrate(), signal);
+        if (refresh) {
+            this.#cancelProbe();
+            this.#failure = undefined;
+        }
+        let force = refresh;
         while (true) {
             signal.throwIfAborted();
             if (this.#disposed)
                 return this.unavailable();
             const cached = this.#cached;
-            if (cached && cached.expires > Date.now())
-                return cached.entry;
+            if (cached && !force)
+                return this.#failure ? { ...cached, refreshFailed: true } : cached;
+            if (!force && this.#failure && Date.now() < this.#failure.retryAt)
+                return this.#failure.entry;
             const pending = this.#ensureProbe();
             const result = await waitForSignal(pending.promise, signal);
             signal.throwIfAborted();
@@ -54,11 +66,41 @@ export class AcpCatalog {
                 return this.unavailable();
             // An invalidation need not have another caller to start its replacement.
             // Only superseded revisions retry; genuine failures remain terminal.
-            if (pending.revision !== this.#revision)
+            if (pending.revision !== this.#revision) {
+                force = !!this.#pending;
                 continue;
+            }
             return result;
         }
     }
+    #hydrate() {
+        if (!this.#hydration) {
+            const revision = this.#revision;
+            this.#hydration = (async () => {
+                const entry = await this.store?.load();
+                if (revision !== this.#revision || !entry)
+                    return;
+                this.#cached = entry;
+            })().catch(() => {
+                // An optional cache must not prevent fresh discovery.
+            });
+        }
+        return this.#hydration;
+    }
+    #save(entry) {
+        if (!this.store)
+            return;
+        const snapshot = entry ? structuredClone(entry) : undefined;
+        // Serialize writes and invalidation so a slow old write cannot resurrect a
+        // deleted snapshot. Every successful probe refreshes the executable binding.
+        this.#writes = this.#writes
+            .then(async () => {
+            await this.store.save(snapshot);
+        })
+            .catch(() => {
+            // Keep the in-memory catalog usable; a later refresh can retry.
+        });
+    }
     #ensureProbe() {
         if (!this.#pending) {
             const revision = this.#revision;
@@ -70,28 +112,38 @@ export class AcpCatalog {
                     // A refresh must drain the superseded process before starting its replacement.
                     await previous;
                     startup.throwIfAborted();
+                    // Failed cleanup may still own the previous permit. Retry it before
+                    // acquiring another permit, including when the budget is only one.
+                    await this.drain();
+                    startup.throwIfAborted();
                     const permit = await this.admission.acquire(startup);
+                    let retained = false;
                     let entry;
                     try {
                         startup.throwIfAborted();
-                        // probe settles only after its process and temporary directory have been disposed.
-                        entry = await this.probe(startup);
+                        entry = await this.probe(startup, (until) => {
+                            retained = true;
+                            void until.then(() => permit.release(), () => permit.release());
+                        });
                     }
                     finally {
-                        permit.release();
+                        if (!retained)
+                            permit.release();
                     }
-                    if (startup.aborted || revision !== this.#revision || this.#disposed)
+                    if (controller.signal.aborted || revision !== this.#revision || this.#disposed)
                         return this.unavailable();
-                    if (entry.readiness === 'ready')
-                        this.#cached = { entry, expires: Date.now() + CATALOG_TTL_MS };
-                    return entry;
+                    if (startup.aborted)
+                        return this.#acceptProbe(this.unavailable());
+                    return this.#acceptProbe(entry);
                 }
                 catch {
+                    // A real timeout is retryable; cancellation/supersession is not a failure.
+                    if (!controller.signal.aborted && revision === this.#revision && !this.#disposed)
+                        return this.#acceptProbe(this.unavailable());
                     return this.unavailable();
                 }
             };
             const promise = run().finally(() => {
-                this.#operations.delete(promise);
                 if (this.#pending?.promise === promise)
                     this.#pending = undefined;
                 if (this.#tail === promise)
@@ -99,20 +151,45 @@ export class AcpCatalog {
             });
             this.#pending = { revision, controller, promise };
             this.#tail = promise;
-            this.#operations.add(promise);
         }
         return this.#pending;
     }
+    #acceptProbe(entry) {
+        if (entry.readiness === 'ready') {
+            this.#failure = undefined;
+            this.#cached = entry;
+            this.#save(entry);
+            return entry;
+        }
+        if (entry.readiness === 'authentication_required') {
+            // A known account failure must not expose the previous account's choices.
+            this.#cached = undefined;
+            this.#hydration = Promise.resolve();
+            this.#save(undefined);
+        }
+        this.#failure = { entry, retryAt: Date.now() + RETRY_COOLDOWN_MS };
+        return this.#cached ? { ...this.#cached, refreshFailed: true } : entry;
+    }
     invalidate() {
-        this.#revision++;
         this.#cached = undefined;
+        this.#failure = undefined;
+        this.#cancelProbe();
+        this.#hydration = Promise.resolve();
+        this.#save(undefined);
+    }
+    #cancelProbe() {
+        this.#revision++;
         this.#pending?.controller.abort(new Error('ACP catalog invalidated'));
         this.#pending = undefined;
     }
     async dispose() {
         this.#disposed = true;
-        this.invalidate();
-        await Promise.allSettled(this.#operations);
+        this.#cancelProbe();
+        // Each replacement awaits its predecessor, including cancelled probes.
+        await this.#tail;
+        await this.#hydration;
+        await this.#writes;
+        this.#cached = undefined;
     }
 }
 /** A caller can stop waiting without cancelling a probe shared by other drafts. */

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

@@ -22,6 +22,7 @@ import { access, mkdir, mkdtemp, realpath, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { AdmissionLimiter } from '@maka/runtime/admission-limiter';
 import { AcpCatalog } from './acp-catalog.js';
+import { createAcpCatalogStore } from './acp-catalog-store.js';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { methods, } from '@agentclientprotocol/sdk';
 import { pluginIdentity } from '@maka/runtime/plugin-runtime';
@@ -40,7 +41,9 @@ export class AcpExecutor {
     #createConnection;
     #state;
     #sessions = new Map();
+    #catalogProbe;
     #disposed = false;
+    #disposal;
     #catalog;
     #withCatalogDirectory;
     #temporaryDirectory;
@@ -67,17 +70,51 @@ export class AcpExecutor {
                         await rm(directory, { recursive: true, force: true });
                     }
                 });
-        this.#catalog = new AcpCatalog(options.catalogAdmission ?? new AdmissionLimiter(1), (signal) => this.#probeCatalog(signal), () => this.#catalogEntry('unavailable'));
+        this.#catalog = new AcpCatalog(options.catalogAdmission ?? new AdmissionLimiter(1), (signal, holdAdmission) => this.#probeCatalog(signal, holdAdmission), () => this.#catalogEntry('unavailable'), () => this.#drainCatalogProbe(), options.catalogPersistence
+            ? createAcpCatalogStore(options.catalogPersistence, this.id, config, this.#configured.launch)
+            : undefined);
     }
     async discover(input) {
         // The generic Host query still supplies its target cwd. ACP draft candidates
         // belong to this configured executor, and never initialize the user's workspace.
         return await this.#catalog.get(input.signal, input.refresh);
     }
-    async #probeCatalog(signal) {
-        return await this.#withCatalogDirectory(signal, (directory) => this.#readCatalog(directory, signal));
+    async #probeCatalog(signal, holdAdmission) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        let releaseDirectory;
+        const released = new Promise((resolve) => {
+            releaseDirectory = resolve;
+        });
+        const probe = { directory: Promise.resolve(), releaseDirectory };
+        this.#catalogProbe = probe;
+        // Report a cleanup failure to discovery while retaining the directory lease
+        // and admission permit until a refresh or shutdown successfully retries it.
+        probe.directory = this.#withCatalogDirectory(signal, async (directory) => {
+            try {
+                resolveResult(await this.#readCatalog(probe, directory, signal));
+            }
+            catch (error) {
+                rejectResult(error);
+            }
+            finally {
+                await released;
+            }
+        }).finally(() => {
+            if (this.#catalogProbe === probe && !probe.session?.owner)
+                this.#catalogProbe = undefined;
+        });
+        holdAdmission(probe.directory);
+        void probe.directory.catch(rejectResult);
+        const entry = await result;
+        await probe.directory;
+        return entry;
     }
-    async #readCatalog(directory, signal) {
+    async #readCatalog(probe, directory, signal) {
         let session;
         try {
             signal.throwIfAborted();
@@ -87,6 +124,7 @@ export class AcpExecutor {
                 configOptions: [],
                 lost: false,
             };
+            probe.session = session;
             await this.#initialize(session, signal, true);
             return this.#catalogEntry('ready', session.configOptions);
         }
@@ -96,9 +134,22 @@ export class AcpExecutor {
         finally {
             // The directory lease outlives process cleanup, including failure cleanup.
             if (session)
-                await (session.loss ?? this.#disposeSession(session));
+                await this.#lose(session);
+            probe.releaseDirectory();
         }
     }
+    async #drainCatalogProbe() {
+        // AcpCatalog serializes probes and drains any retained owner before replacement.
+        const probe = this.#catalogProbe;
+        if (!probe)
+            return;
+        if (probe.session)
+            await this.#lose(probe.session);
+        probe.releaseDirectory();
+        await probe.directory;
+        if (this.#catalogProbe === probe)
+            this.#catalogProbe = undefined;
+    }
     invalidateCatalog() {
         this.#catalog.invalidate();
     }
@@ -308,18 +359,32 @@ export class AcpExecutor {
             await this.#lose(session);
     }
     async dispose() {
-        if (this.#disposed)
-            return;
+        if (this.#disposal)
+            return await this.#disposal;
         this.#disposed = true;
+        this.#disposal = this.#dispose().catch((error) => {
+            this.#disposal = undefined;
+            throw error;
+        });
+        await this.#disposal;
+    }
+    async #dispose() {
         await this.#catalog.dispose();
-        const sessions = [...this.#sessions.values()];
-        this.#sessions.clear();
-        const settlements = await Promise.allSettled(sessions.map((session) => session.loss ?? this.#disposeSession(session)));
+        const settlements = await Promise.allSettled([
+            ...[...this.#sessions.values()].map(async (session) => {
+                await this.#lose(session);
+                if (this.#sessions.get(session.conversationKey) === session)
+                    this.#sessions.delete(session.conversationKey);
+            }),
+            this.#drainCatalogProbe(),
+        ]);
         const failures = settlements.flatMap((settlement) => settlement.status === 'rejected' ? [settlement.reason] : []);
         if (failures.length)
             throw new AggregateError(failures, 'ACP process cleanup failed');
     }
     async #session(request) {
+        if (this.#disposed)
+            throw new AcpRuntimeError('ACP executor is unavailable', 'acp_unavailable');
         const cwd = resolve(request.cwd);
         const existing = this.#sessions.get(request.conversationKey);
         if (existing) {
@@ -331,7 +396,9 @@ export class AcpExecutor {
                 throw new AcpRuntimeError('ACP Session is busy', 'acp_busy');
             if (!existing.record)
                 throw new AcpRuntimeError('ACP conversation is history-only because its external process was lost', 'acp_history_only');
-            await existing.loss;
+            await this.#lose(existing);
+            if (this.#disposed)
+                throw new AcpRuntimeError('ACP executor is unavailable', 'acp_unavailable');
             if (this.#sessions.get(request.conversationKey) !== existing)
                 return this.#session(request);
             this.#sessions.delete(request.conversationKey);
@@ -394,6 +461,9 @@ export class AcpExecutor {
             throw new AcpRuntimeError('ACP Agent installation changed', 'acp_restore_identity_changed');
         const executable = await checkedExecutable(launch.executable);
         await Promise.all((launch.requiredExecutables ?? []).map(checkedExecutable));
+        // Closing may have started while startup was reading state or checking binaries.
+        if (this.#disposed || session.lost)
+            throw new AcpRuntimeError('ACP executor is unavailable', 'acp_unavailable');
         const owner = this.#createConnection({
             ...launch,
             executable,
@@ -848,18 +918,23 @@ export class AcpExecutor {
             throw new Error('Unknown ACP Session');
     }
     async #lose(session) {
+        session.lost = true;
+        session.connection = undefined;
         if (!session.loss) {
-            session.lost = true;
-            session.loss = this.#disposeSession(session);
+            session.loss = this.#disposeSession(session).catch((error) => {
+                // Keep the owner until cleanup succeeds, and let a later caller retry failures.
+                session.loss = undefined;
+                throw error;
+            });
         }
         await session.loss;
     }
     async #disposeSession(session) {
         const owner = session.owner;
-        session.owner = undefined;
         session.connection = undefined;
         if (owner)
             await owner.dispose();
+        session.owner = undefined;
     }
 }
 function currentAcpModel(options) {
@@ -913,6 +988,7 @@ export class AcpRuntimeService {
         const provider = new AcpExecutor(adapter, config, {
             state: pluginStateStore(storage, adapter.id),
             catalogAdmission: this.#catalogAdmission,
+            catalogPersistence: { storage, key: `${directoryKey}/snapshot` },
             withCatalogDirectory: (signal, use) => storage.withScratchDirectory(directoryKey, signal, use),
         });
         consumer.effect(() => () => provider.dispose(), `acp.dispose(${JSON.stringify(adapter.id)})`);