@dev-mainsequence/codex-plugin 0.7.10 → 0.7.12

package/dist/vendor/devtools/shared/projectTools.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectToolCatalogPath = exports.projectToolConnectionLabel = exports.isProjectToolName = exports.MAX_PROJECT_TOOL_TIMEOUT_MS = exports.DEFAULT_PROJECT_REQUEST_TIMEOUT_MS = exports.PROJECT_TOOL_TIMEOUT_HINT = exports.MAX_PROJECT_TOOLS_PER_CONNECTION = exports.PROJECT_TOOL_PREFIX = void 0;
+exports.projectToolCatalogPath = exports.projectToolConnectionLabel = exports.isProjectToolName = exports.DEFAULT_PROJECT_REFRESH_BUDGET_MS = exports.MAX_PROJECT_TOOL_TIMEOUT_MS = exports.DEFAULT_PROJECT_REQUEST_TIMEOUT_MS = exports.PROJECT_TOOL_TIMEOUT_HINT = exports.MAX_PROJECT_TOOLS_PER_CONNECTION = exports.PROJECT_TOOL_PREFIX = void 0;
 exports.projectToolName = projectToolName;
 exports.projectToolConnection = projectToolConnection;
 exports.projectToolDefinition = projectToolDefinition;
@@ -51,12 +51,16 @@ const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const models_1 = require("./models.js");
 const stateDirectory_1 = require("./stateDirectory.js");
+const repositories_1 = require("./repositories.js");
 exports.PROJECT_TOOL_PREFIX = 'ms_';
 exports.MAX_PROJECT_TOOLS_PER_CONNECTION = 80;
 /** A project may advertise how long one of its tools can take; the client honours it up to the cap. */
 exports.PROJECT_TOOL_TIMEOUT_HINT = 'mainsequence.ai/timeout-seconds/v1';
 exports.DEFAULT_PROJECT_REQUEST_TIMEOUT_MS = 120_000;
 exports.MAX_PROJECT_TOOL_TIMEOUT_MS = 300_000;
+/** A whole refresh, every connection included: a cold project answers `initialize` in up to 120 s, and a
+ * host must not hold the shared lock for the 13 minutes once measured. */
+exports.DEFAULT_PROJECT_REFRESH_BUDGET_MS = 300_000;
 const CATALOG_FILE = 'project-tool-catalog.json';
 const LOCK_STALE_MS = 10 * 60_000;
 const UUID = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i;
@@ -173,12 +177,15 @@ function success(result) {
     return result.data;
 }
 /** Every saved connection in scope and its current tools: `mcp-list` (read-only), then one `mcp-tools`
- * per connection, two at a time (the shared transport's per-origin limit). A connection whose catalog
- * cannot be read now keeps its `previous` tools and is named in `unavailable`; a removed connection
- * loses them; connections outside the scope are carried over from `previous` unchanged. No account
- * snapshot is attached: a registered tool is bound to a saved connection, and the session for that
- * connection's backend is verified when the tool is called. */
+ * per connection, two at a time (the shared transport's per-origin limit), all within one budget. A
+ * connection whose catalog cannot be read now, or is not read before the budget runs out, stays in the
+ * catalog marked `unavailable` with the reason, keeping its `previous` tools when it had any, so a scope
+ * is never written empty and healthy when its connections exist; a removed connection loses its tools;
+ * connections outside the scope are carried over from `previous` unchanged. No account snapshot is
+ * attached: a registered tool is bound to a saved connection, and the session for that connection's
+ * backend is verified when the tool is called. */
 async function readProjectToolCatalog(dispatch, options = {}) {
+    const started = Date.now(), budgetMs = options.budgetMs ?? exports.DEFAULT_PROJECT_REFRESH_BUDGET_MS;
     const status = options.session ?? success(await dispatch({ action: 'auth-status', ...(options.backend ? { backend: options.backend } : {}) }));
     if (!status.authenticated || !status.backend)
         throw new models_1.ToolingError('NOT_AUTHENTICATED', 'Sign in to MainSequence to register saved project MCP tools.');
@@ -189,39 +196,57 @@ async function readProjectToolCatalog(dispatch, options = {}) {
     const rows = success(await dispatch({ action: 'mcp-list', backend, readOnly: true, ...environment }));
     const previous = options.previous?.connections ?? [];
     const connections = previous.filter(connection => !inScope(connection, scope)), unavailable = [];
-    let retained = 0;
+    let retained = 0, expired = false, timer;
+    const budget = new Promise(resolve => { timer = setTimeout(() => { expired = true; resolve('budget'); }, Math.max(0, budgetMs - (Date.now() - started))); });
+    const seconds = budgetMs >= 1000 ? `${Math.round(budgetMs / 1000)} s` : `${budgetMs} ms`;
+    function unreadable(row, code, message) {
+        const earlier = previous.find(connection => connection.backend === backend && connection.releaseUid === row.resource_release_uid.toLowerCase());
+        if (earlier)
+            retained += earlier.tools.length;
+        connections.push({ ...(earlier ?? projectToolConnection(row)), unavailable: { at: new Date().toISOString(), code, message } });
+        unavailable.push((0, exports.projectToolConnectionLabel)(row));
+    }
     const pending = [...rows];
-    await Promise.all(Array.from({ length: Math.min(2, pending.length) }, async () => {
-        while (pending.length) {
-            options.signal?.throwIfAborted();
-            const row = pending.shift();
-            try {
-                const output = success(await dispatch({ action: 'mcp-tools', backend, releaseUid: row.resource_release_uid, ...environment }));
-                const current = output.connection;
-                connections.push(projectToolConnection({ ...row, name: row.name ?? current?.name, display_name: row.display_name ?? current?.display_name,
-                    mcp_connection: { ...row.mcp_connection, organization_environment_name: row.mcp_connection.organization_environment_name ?? current?.mcp_connection?.organization_environment_name } }, output.tools));
-            }
-            catch (error) {
-                if (error instanceof models_1.ToolingError && error.code === 'CANCELLED')
-                    throw error;
+    try {
+        await Promise.all(Array.from({ length: Math.min(2, pending.length) }, async () => {
+            while (pending.length && !expired) {
                 options.signal?.throwIfAborted();
-                const earlier = previous.find(connection => connection.backend === backend && connection.releaseUid === row.resource_release_uid.toLowerCase());
-                if (earlier) {
-                    connections.push(earlier);
-                    retained += earlier.tools.length;
+                const row = pending.shift();
+                try {
+                    const outcome = await Promise.race([Promise.resolve(dispatch({ action: 'mcp-tools', backend, releaseUid: row.resource_release_uid, ...environment })).then(result => ({ result })), budget]);
+                    if (outcome === 'budget') {
+                        unreadable(row, 'TIMEOUT', `Not read within the ${seconds} refresh budget; its earlier tools stay registered until a later refresh reads it.`);
+                        break;
+                    }
+                    const output = success(outcome.result), current = output.connection;
+                    connections.push(projectToolConnection({ ...row, name: row.name ?? current?.name, display_name: row.display_name ?? current?.display_name,
+                        mcp_connection: { ...row.mcp_connection, organization_environment_name: row.mcp_connection.organization_environment_name ?? current?.mcp_connection?.organization_environment_name } }, output.tools));
+                }
+                catch (error) {
+                    if (error instanceof models_1.ToolingError && error.code === 'CANCELLED')
+                        throw error;
+                    options.signal?.throwIfAborted();
+                    unreadable(row, error instanceof models_1.ToolingError ? error.code : 'INTERNAL_ERROR', error instanceof models_1.ToolingError ? error.message : 'The catalog could not be read.');
                 }
-                unavailable.push((0, exports.projectToolConnectionLabel)(row));
             }
-        }
-    }));
+        }));
+        // Whatever the budget left unread is reported, never silently dropped.
+        for (const row of pending)
+            unreadable(row, 'TIMEOUT', `Not read within the ${seconds} refresh budget; its earlier tools stay registered until a later refresh reads it.`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
     connections.sort((a, b) => a.backend.localeCompare(b.backend) || a.environmentUid.localeCompare(b.environmentUid) || a.releaseUid.localeCompare(b.releaseUid));
-    return { catalog: { version: 1, updatedAt: new Date().toISOString(), connections }, backend, unavailable, retained };
+    return { catalog: { version: 1, updatedAt: new Date().toISOString(), connections }, backend, unavailable, retained, durationMs: Date.now() - started };
 }
 function connectionRecord(value) {
     if (!object(value) || typeof value.backend !== 'string' || !UUID.test(String(value.releaseUid)) || !UUID.test(String(value.environmentUid)) || !Array.isArray(value.tools))
         return;
+    const u = value.unavailable;
     return { backend: value.backend, releaseUid: String(value.releaseUid).toLowerCase(), environmentUid: String(value.environmentUid).toLowerCase(),
-        environmentName: text(value.environmentName), name: text(value.name), tools: normalizeTools(value.tools) };
+        environmentName: text(value.environmentName), name: text(value.name), tools: normalizeTools(value.tools),
+        ...(object(u) && typeof u.code === 'string' && typeof u.message === 'string' ? { unavailable: { at: text(u.at, 40), code: text(u.code, 60), message: text(u.message, 1000) } } : {}) };
 }
 /** Beside `mcp-connections.json`, shared by every host on the machine. */
 const projectToolCatalogPath = (env = process.env) => path.join((0, stateDirectory_1.mainSequenceStateDirectory)(env), CATALOG_FILE);
@@ -250,10 +275,12 @@ function createProjectToolCatalog(options) {
     const file = options.file ?? (0, exports.projectToolCatalogPath)(options.env), staleMs = options.staleMs ?? 15 * 60_000;
     let catalog = readProjectToolCatalogFile(file), loadedAt = mtime(), running = null;
     let current = null;
-    // The scope of the last refresh: the current account's backend (learned from auth-status), so a
-    // listing shows this host's connections even when another backend's are cached beside them.
-    let known;
-    const state = { unavailable: [], retained: 0, error: null };
+    // The backend this host's listing is for: given by the host, resolved by ready() the way auth-status
+    // resolves it, or learned from a refresh. The file is shared by every host and backend on the machine,
+    // so until it is known a listing shows nothing rather than another backend's tools.
+    let known = options.backend ? { backend: options.backend } : undefined;
+    let readying = null;
+    const state = { error: null };
     function mtime() { try {
         return fs.statSync(file).mtimeMs;
     }
@@ -268,7 +295,9 @@ function createProjectToolCatalog(options) {
         catalog = readProjectToolCatalogFile(file);
         loadedAt = now;
     }
-    const registration = (scope) => projectToolRegistration(catalog, scope ?? known);
+    const none = { definitions: [], bindings: new Map() };
+    const registration = (scope) => (scope ?? known) ? projectToolRegistration(catalog, scope ?? known) : none;
+    const selected = (scope) => (catalog?.connections ?? []).filter(connection => (scope ?? known) ? inScope(connection, scope ?? known) : false);
     async function write(next) {
         await fsp.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
         const temporary = `${file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
@@ -330,16 +359,27 @@ function createProjectToolCatalog(options) {
     }
     return {
         file,
-        /** Definitions for the host's tool list, from the newest shared cache. */
+        /** The backend this listing is for, resolved once without any network request (the process
+         * environment, then the shared preferences, then the default), as `auth-status` resolves it. A
+         * host calls this before its first tool list; a refresh or an explicit scope also sets it. */
+        ready() {
+            if (known)
+                return Promise.resolve();
+            readying ??= (0, repositories_1.resolveBackend)(undefined, undefined, options.env ?? process.env).then(backend => { known ??= { backend }; }, () => { });
+            return readying;
+        },
+        /** Definitions for the host's tool list, from the newest shared cache, for the known backend only. */
         list(scope) { reload(); return registration(scope).definitions; },
         binding(name) { reload(); return registration({}).bindings.get(name); },
         state(scope) {
             reload();
-            const selected = scope ?? known;
+            const connections = selected(scope), unavailable = connections.filter(connection => connection.unavailable);
             return { count: registration(scope).definitions.length,
-                connections: (catalog?.connections ?? []).filter(connection => inScope(connection, selected)).map(connection => ({ backend: connection.backend, releaseUid: connection.releaseUid,
-                    environmentUid: connection.environmentUid, environmentName: connection.environmentName, name: connection.name, tools: connection.tools.length })),
-                updatedAt: catalog?.updatedAt || null, refreshing: running !== null, unavailable: state.unavailable, retained: state.retained, error: state.error };
+                connections: connections.map(connection => ({ backend: connection.backend, releaseUid: connection.releaseUid, environmentUid: connection.environmentUid, environmentName: connection.environmentName,
+                    name: connection.name, tools: connection.tools.length, ...(connection.unavailable ? { unavailable: connection.unavailable } : {}) })),
+                updatedAt: catalog?.updatedAt || null, refreshing: running !== null,
+                // Read from the file, so a host whose process did not run the refresh still sees what it could not read.
+                unavailable: unavailable.map(connection => connection.name || connection.releaseUid), retained: unavailable.reduce((sum, connection) => sum + connection.tools.length, 0), error: state.error };
         },
         /** The state plus definitions and bindings, as the `mcp-catalog` action returns them. */
         view(scope) {
@@ -383,10 +423,8 @@ function createProjectToolCatalog(options) {
                     current.locked = true;
                     try {
                         reload();
-                        const read = await readProjectToolCatalog(dispatch, { ...scope, backend: session.backend, previous: catalog, signal: controller.signal, session });
+                        const read = await readProjectToolCatalog(dispatch, { ...scope, backend: session.backend, previous: catalog, signal: controller.signal, session, budgetMs: options.budgetMs });
                         await write(read.catalog);
-                        state.unavailable = read.unavailable;
-                        state.retained = read.retained;
                         state.error = null;
                         adopt(read.catalog, scope ?? { backend: read.backend });
                         return true;
@@ -400,7 +438,12 @@ function createProjectToolCatalog(options) {
                     state.error = { code: error instanceof models_1.ToolingError ? error.code : 'INTERNAL_ERROR', message: error instanceof models_1.ToolingError ? error.message : 'The saved project MCP tools could not be refreshed.' };
                     return false;
                 }
-            })().finally(() => { running = null; current = null; });
+            })().finally(() => {
+                // A read the budget left behind must not keep a socket or the dispatcher alive.
+                controller.abort();
+                running = null;
+                current = null;
+            });
             return running;
         },
         /** A host process is ending: stop its refresh and free the shared lock for the next one at once. */
@@ -425,7 +468,8 @@ function createProjectToolCatalog(options) {
                 void this.refresh(true);
                 return;
             }
-            const connections = catalog.connections.map((item, i) => i === index ? { ...item, tools: normalizeTools(tools) } : item);
+            // A catalog just read is a successful read: the connection is available again.
+            const connections = catalog.connections.map((item, i) => i === index ? { ...item, tools: normalizeTools(tools), unavailable: undefined } : item);
             const next = { version: 1, updatedAt: new Date().toISOString(), connections };
             try {
                 await write(next);