@yugabytedb/meko-mcp 2.3.0 → 2.5.1

package/lib/migrate/datapack.mjs

@@ -8,11 +8,19 @@
  * confirmation of the default-fallback case. This module owns the lookup.
  *
  * Wire model: the MCP server routes by `datapack_id` parameter, not URL host.
- * `datapack_list` returns the user's visible packs; we resolve here, then the
- * orchestrator threads `datapack_id` into every subsequent `tools/call`.
+ * We resolve here, then the orchestrator threads `datapack_id` into every
+ * subsequent `tools/call`.
+ *
+ * Lookups go through `datapack_search(name=...)` and `datapack_describe`, so
+ * they cost the same for an account with 1M datapacks as for one with two.
+ * A server whose tools/list has no `datapack_search` predates it; there we
+ * fall back to scanning `datapack_list`, which is fine for the account sizes
+ * such a server can serve.
  */
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const DEFAULT_DATAPACK_NAME = "meko_default_datapack";
+const NIL_CONVERSATION_ID = "00000000-0000-0000-0000-000000000000";
+const SUGGESTION_LIMIT = 10;
 
 export function isUuid(value) {
   return typeof value === "string" && UUID_RE.test(value);
@@ -50,7 +58,8 @@ export function parseDatapackList(text) {
  * Resolve the destination datapack for a migration.
  *
  * @param {object} opts
- * @param {{callTool: Function}} opts.client    Connected McpClient.
+ * @param {{callTool: Function, listTools?: Function}} opts.client
+ *                                              Connected McpClient.
  * @param {string|null} opts.requested          Raw `--datapack` value (UUID or
  *                                              name) or null for default.
  * @returns {Promise<{
@@ -68,20 +77,239 @@ export function parseDatapackList(text) {
  *   - `server-fallback`: requested=null and no default row found in the list;
  *     we let the server's own fallback chain handle it (id stays null).
  *
- * `defaultId` is the id of the `meko_default_datapack` row if visible — surfaced
- * even when `requested` is non-null so the caller can detect "user named the
- * default explicitly" and reuse the same on-disk state file.
+ * `defaultId` is the id of the `meko_default_datapack` row if visible, so the
+ * caller can detect "user named the default explicitly" and reuse the same
+ * on-disk state file. With `datapack_search`, an explicit `requested` whose
+ * datapack has another name gets `defaultId: null` without a lookup: its id
+ * can't match the default's, and skipping the lookup keeps a failure there
+ * from failing the request.
  *
  * Failure cases (`ok: false`):
- *   - `datapack_list` call failed (auth, network, server error).
- *   - response body wasn't a recognizable datapack list.
- *   - explicit override didn't match any row.
+ *   - the lookup call failed (auth, network, server error).
+ *   - response body wasn't recognizable.
+ *   - explicit override didn't match any visible datapack.
  */
 export async function resolveDestinationDatapack(opts) {
   const { client, requested } = opts;
+  if (await hasTool(client, "datapack_search")) {
+    return resolveWithSearch(client, requested);
+  }
+  return resolveWithListScan(client, requested);
+}
+
+/**
+ * Whether the server lists `name`. A client without `listTools` (a test
+ * double) or a failed tools/list reads as "no", which selects the
+ * `datapack_list` scan every server supports.
+ */
+async function hasTool(client, name) {
+  if (typeof client.listTools !== "function") return false;
+  try {
+    const names = await client.listTools();
+    return Array.isArray(names) && names.includes(name);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parse a `datapack_search` response body into its rows, or return
+ * `{error}` naming what went wrong. Rows are summary rows (no credentials),
+ * but the body is still never echoed.
+ *
+ * @param {{ok: boolean, text?: string, error?: object}} res
+ * @returns {{rows: Array} | {error: string}}
+ */
+export function parseDatapackSearch(res) {
+  if (!res.ok) return { error: res.error?.message ?? "unknown" };
+  let body;
+  try {
+    body = JSON.parse(res.text ?? "");
+  } catch {
+    return { error: "unrecognized response shape" };
+  }
+  if (body && typeof body === "object" && typeof body.error === "string") {
+    const detail = typeof body.detail === "string" ? ` (${body.detail})` : "";
+    return { error: `${body.error}${detail}` };
+  }
+  if (!body || !Array.isArray(body.datapacks)) {
+    return { error: "unrecognized response shape" };
+  }
+  const rows = body.datapacks.filter(
+    (e) => e && typeof e === "object" && typeof e.datapack_id === "string",
+  );
+  return { rows };
+}
+
+function search(client, args) {
+  return client.callTool("datapack_search", {
+    conversation_id: NIL_CONVERSATION_ID,
+    ...args,
+  });
+}
+
+/**
+ * The row named exactly `name`. An owned row is requested first, with
+ * `grant: "owner"`, so a page of newer shared copies of the same name
+ * cannot hide it. If the caller owns none, the first exact match of any
+ * grant is used.
+ */
+async function findByName(client, name) {
+  const owned = parseDatapackSearch(
+    await search(client, { name, grant: "owner", limit: 100 }),
+  );
+  if (owned.error) return owned;
+  const ownedHit = owned.rows.find(
+    (d) => d.datapack_name === name && d.grant === "owner",
+  );
+  if (ownedHit) return { row: ownedHit };
+
+  const found = parseDatapackSearch(await search(client, { name, limit: 100 }));
+  if (found.error) return found;
+  const exact = found.rows.filter((d) => d.datapack_name === name);
+  return { row: exact[0] ?? null };
+}
+
+async function resolveWithSearch(client, requested) {
+  if (!requested) {
+    const def = await findByName(client, DEFAULT_DATAPACK_NAME);
+    if (def.error) {
+      return {
+        ok: false,
+        message: `datapack_search failed: ${def.error}. Cannot resolve --datapack.`,
+      };
+    }
+    const defaultRow = def.row;
+    if (defaultRow) {
+      return {
+        ok: true,
+        id: defaultRow.datapack_id,
+        name: defaultRow.datapack_name,
+        source: "default",
+        defaultId: defaultRow.datapack_id,
+      };
+    }
+    return { ok: true, id: null, name: null, source: "server-fallback", defaultId: null };
+  }
+
+  const found = await resolveRequested(client, requested);
+  if (!found.ok) return found;
+  const def = await defaultIdFor(client, requested, found.row);
+  if (def.error) {
+    return {
+      ok: false,
+      message:
+        `datapack_search failed: ${def.error}. Cannot tell whether --datapack ` +
+        `${requested} is your default datapack.`,
+    };
+  }
+  return {
+    ok: true,
+    id: found.row.datapack_id,
+    name: found.row.datapack_name ?? null,
+    source: found.source,
+    defaultId: def.id,
+  };
+}
+
+/**
+ * The id of the caller's `meko_default_datapack`, or null, for comparing with
+ * an explicitly requested datapack. A row with any other name can't be the
+ * default, so the lookup runs only when the requested datapack carries the
+ * default's name or its name is unknown. That keeps a failure in a lookup the
+ * request doesn't need from failing the request.
+ *
+ * @returns {Promise<{id: string|null} | {error: string}>}
+ */
+async function defaultIdFor(client, requested, row) {
+  const name = row.datapack_name;
+  if (typeof name === "string" && name !== DEFAULT_DATAPACK_NAME) {
+    return { id: null };
+  }
+  // findByName already resolved the default's name, owner first.
+  if (requested === DEFAULT_DATAPACK_NAME) return { id: row.datapack_id };
+  const def = await findByName(client, DEFAULT_DATAPACK_NAME);
+  if (def.error) return def;
+  return { id: def.row?.datapack_id ?? null };
+}
+
+/**
+ * Resolve an explicit `--datapack` to `{ok: true, row, source}`, or to the
+ * `{ok: false, message}` the caller returns as is.
+ */
+async function resolveRequested(client, requested) {
+  if (isUuid(requested)) {
+    const res = await client.callTool("datapack_describe", {
+      datapack_id: requested,
+      conversation_id: NIL_CONVERSATION_ID,
+    });
+    const hit = parseDescribe(res);
+    if (hit.error) {
+      return {
+        ok: false,
+        message:
+          `--datapack ${requested}: no datapack with that id is visible to ` +
+          `this API key (${hit.error}).`,
+      };
+    }
+    return { ok: true, row: hit.row, source: "flag-id" };
+  }
+
+  const byName = await findByName(client, requested);
+  if (byName.error) {
+    return {
+      ok: false,
+      message: `datapack_search failed: ${byName.error}. Cannot resolve --datapack.`,
+    };
+  }
+  if (!byName.row) {
+    const similar = parseDatapackSearch(
+      await search(client, { query: requested, limit: SUGGESTION_LIMIT }),
+    );
+    if (similar.error) {
+      return {
+        ok: false,
+        message: `datapack_search failed: ${similar.error}. Cannot resolve --datapack.`,
+      };
+    }
+    const hint = similar.rows.length
+      ? `Similar names: ${formatNames(similar.rows)}.`
+      : "No datapack name contains that text.";
+    return {
+      ok: false,
+      message:
+        `--datapack ${JSON.stringify(requested)}: no datapack with that name. ` +
+        hint,
+    };
+  }
+  return { ok: true, row: byName.row, source: "flag-name" };
+}
+
+/**
+ * Parse a `datapack_describe` body into `{row}` or `{error}`. Only the id
+ * and name are read; the body is never echoed.
+ */
+function parseDescribe(res) {
+  if (!res.ok) return { error: res.error?.message ?? "unknown" };
+  let body;
+  try {
+    body = JSON.parse(res.text ?? "");
+  } catch {
+    return { error: "unrecognized response shape" };
+  }
+  if (body && typeof body === "object" && typeof body.error === "string") {
+    return { error: body.error };
+  }
+  if (!body || typeof body.datapack_id !== "string") {
+    return { error: "unrecognized response shape" };
+  }
+  return { row: body };
+}
+
+async function resolveWithListScan(client, requested) {
   const res = await client.callTool("datapack_list", {
     scope: "read",
-    conversation_id: "00000000-0000-0000-0000-000000000000",
+    conversation_id: NIL_CONVERSATION_ID,
   });
   if (!res.ok) {
     return {
@@ -101,7 +329,7 @@ export async function resolveDestinationDatapack(opts) {
     };
   }
 
-  const defaultRow = list.find((d) => d.datapack_name === DEFAULT_DATAPACK_NAME);
+  const defaultRow = namedRow(list, DEFAULT_DATAPACK_NAME);
   const defaultId = defaultRow?.datapack_id ?? null;
 
   if (!requested) {
@@ -136,7 +364,7 @@ export async function resolveDestinationDatapack(opts) {
     };
   }
 
-  const hit = list.find((d) => d.datapack_name === requested);
+  const hit = namedRow(list, requested);
   if (!hit) {
     return {
       ok: false,
@@ -154,14 +382,24 @@ export async function resolveDestinationDatapack(opts) {
   };
 }
 
+function namedRow(list, name) {
+  const exact = list.filter((d) => d.datapack_name === name);
+  return exact.find((d) => d.grant === "owner") ?? exact[0] ?? null;
+}
+
 /**
  * Format a one-line "Available: a, b, c" hint. Names only — never ids,
  * because the underlying response can carry credentials.
  */
 function formatAvailable(list) {
-  const names = list
+  const names = formatNames(list);
+  if (!names) return "(no datapacks visible to this API key.)";
+  return `Available: ${names}.`;
+}
+
+function formatNames(list) {
+  return list
     .map((d) => d.datapack_name)
-    .filter((n) => typeof n === "string" && n.length > 0);
-  if (names.length === 0) return "(no datapacks visible to this API key.)";
-  return `Available: ${names.join(", ")}.`;
+    .filter((n) => typeof n === "string" && n.length > 0)
+    .join(", ");
 }

package/lib/migrate/mcp-client.mjs

@@ -79,6 +79,40 @@ export class McpClient {
     }
   }
 
+  /**
+   * Names of the tools the server lists over the open session. Throws when
+   * the request fails, so callers can decide how to degrade.
+   *
+   * @param {{timeoutMs?: number}} [opts]
+   * @returns {Promise<string[]>}
+   */
+  async listTools(opts = {}) {
+    await this._acquire();
+    try {
+      const res = await jsonRpcRequest(
+        this.url,
+        { jsonrpc: "2.0", id: this._reqId++, method: "tools/list", params: {} },
+        this.apiKey,
+        this.sessionId,
+        { timeoutMs: opts.timeoutMs ?? this.timeoutMs },
+      );
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        const e = new Error(`tools/list returned HTTP ${res.statusCode}`);
+        e.statusCode = res.statusCode;
+        throw e;
+      }
+      const parsed = JSON.parse(res.body);
+      if (parsed.error) {
+        throw new Error(`tools/list error: ${parsed.error.message ?? "unknown"}`);
+      }
+      const tools = parsed.result?.tools;
+      if (!Array.isArray(tools)) throw new Error("tools/list returned no tools array");
+      return tools.map((t) => t?.name).filter((n) => typeof n === "string");
+    } finally {
+      this._release();
+    }
+  }
+
   async _callWithRetry(name, args, opts) {
     const maxRetries = opts.maxRetries ?? 3;
     let lastErr = null;

package/lib/migrate/orchestrator.mjs

@@ -287,7 +287,7 @@ export async function runMigration(opts) {
     return { ok: false, summary: { error: "mcp_connect_failed", detail: err.message }, counts: prog.counts };
   }
 
-  // Resolve --datapack against the live datapack_list so every subsequent
+  // Resolve --datapack against the live server so every subsequent
   // tools/call carries an explicit datapack_id. Without this we'd be silently
   // relying on the server's tenant-context default — fine when it's correct,
   // invisible when it isn't.

package/lib/migrate.mjs

@@ -20,7 +20,7 @@ import * as progress from "./migrate/progress.mjs";
 import { datapackKeyFromUrl } from "./migrate/id.mjs";
 import { resolveDestinationDatapack } from "./migrate/datapack.mjs";
 import { McpClient } from "./migrate/mcp-client.mjs";
-import { selfInvocation } from "./clients/common.mjs";
+import { isLocalUrl, selfInvocation } from "./clients/common.mjs";
 import { askYesNo } from "./prompt.mjs";
 
 function home() {
@@ -302,7 +302,7 @@ export async function startMigration(opts) {
   // Pre-flight: resolve the destination datapack *before* taking the lock or
   // forking the child. A typo in --datapack should fail fast with a useful
   // error, not after the child has spun up. We open a short-lived MCP client
-  // here purely for the datapack_list call; the child opens its own session.
+  // here purely for the datapack lookup; the child opens its own session.
   // The resolved id isn't persisted into passthrough — the child re-resolves,
   // which costs one extra cheap read but keeps the wire-level routing
   // logic in a single place.
@@ -764,7 +764,3 @@ export async function stopMigration() {
     message: `Force-killed pid=${holder.pid} (run-id=${holder.runId}).`,
   };
 }
-
-function isLocalUrl(url) {
-  return /localhost|127\.0\.0\.1/.test(url ?? "");
-}

package/lib/validate.mjs

@@ -38,8 +38,13 @@ const CORE_TOOLS = [
 /** Nil UUID used as the conversation_id placeholder for the canary call. */
 const NIL_UUID = "00000000-0000-0000-0000-000000000000";
 
-/** Tool the canary invokes. */
-const CANARY_TOOL = "datapack_list";
+/**
+ * Tool the canary invokes. `datapack_search(limit=1)` reads one page whatever
+ * the account size; a server that predates it gets `datapack_list`, which
+ * reads the whole account.
+ */
+const CANARY_TOOL = "datapack_search";
+const LEGACY_CANARY_TOOL = "datapack_list";
 
 // ---------------------------------------------------------------------------
 // 1. Config validation
@@ -139,9 +144,10 @@ export async function validateTools(url, apiKey) {
  * The canary's job is to prove the part of the stack that connectivity +
  * tools/list don't cover: auth was accepted as a real Meko identity, the
  * tenant resolver mapped it to an account, and the datapack routing wired
- * up the user's actual workspace. We invoke `datapack_list` for this — it
- * is a single read-only call, runs a short SQL query against the system
- * schema, and returns deterministically (every authenticated user has at
+ * up the user's actual workspace. We invoke `datapack_search(limit=1)` for
+ * this, or `datapack_list` on a server whose tools/list has no
+ * `datapack_search`. Either is a single read-only call against the system
+ * schema and returns deterministically (every authenticated user has at
  * least one datapack: their default).
  *
  * Why not memory_add? The previous canary did a write/read/delete round-trip
@@ -166,11 +172,13 @@ export async function validateTools(url, apiKey) {
  *                                       initialize handshake is performed.
  * @param {number} [options.timeoutMs] - Override the canary call's transport timeout.
  *                                       Defaults to DEFAULT_REQUEST_TIMEOUT_MS.
+ * @param {string[]} [options.toolNames] - Tool names from an earlier tools/list.
+ *                                       If omitted, the canary lists tools itself.
  * @returns {Promise<{
  *   ok: boolean,
  *   message: string,
  *   datapack_count: number|null,
- *   step?: "initialize"|"datapack_list",
+ *   step?: "initialize"|"datapack_search"|"datapack_list",
  * }>}
  */
 export async function validateCanary(url, apiKey, options = {}) {
@@ -190,11 +198,77 @@ export async function validateCanary(url, apiKey, options = {}) {
     sessionId = init.sessionId;
   }
 
+  let toolNames = options.toolNames;
+  if (!Array.isArray(toolNames)) {
+    // A failed listing just means we cannot tell; datapack_list works on
+    // every server.
+    const listed = await sendToolsList(url, apiKey, sessionId);
+    toolNames = listed.tools;
+  }
+  if (toolNames.includes(CANARY_TOOL)) {
+    return searchCanary(url, apiKey, sessionId, timeoutMs);
+  }
+  return listCanary(url, apiKey, sessionId, timeoutMs);
+}
+
+async function searchCanary(url, apiKey, sessionId, timeoutMs) {
   const callRes = await mcpCallTool(
     url,
     apiKey,
     sessionId,
     CANARY_TOOL,
+    { conversation_id: NIL_UUID, limit: 1 },
+    { timeoutMs },
+  );
+  if (!callRes.ok) {
+    return {
+      ok: false,
+      datapack_count: null,
+      step: CANARY_TOOL,
+      message: `Canary: ${callRes.message}`,
+    };
+  }
+
+  const datapacks = parseDatapackSearchPage(callRes.text);
+  if (!datapacks) {
+    return {
+      ok: false,
+      datapack_count: null,
+      step: CANARY_TOOL,
+      message:
+        `Canary: ${CANARY_TOOL} returned an unexpected response shape ` +
+        `(expected an object with a datapacks array). Check the server logs.`,
+    };
+  }
+  if (datapacks.length === 0) {
+    return zeroDatapacks(CANARY_TOOL);
+  }
+  return {
+    ok: true,
+    datapack_count: datapacks.length,
+    message: `Canary OK — ${CANARY_TOOL} found a datapack.`,
+  };
+}
+
+function zeroDatapacks(tool) {
+  return {
+    ok: false,
+    datapack_count: 0,
+    step: tool,
+    message:
+      `Canary: ${tool} returned zero datapacks. Every authenticated ` +
+      `Meko user should have at least their default datapack — this likely ` +
+      `means the API token authenticated but resolved to the wrong tenant. ` +
+      `Verify the API key matches the tenant the URL points at.`,
+  };
+}
+
+async function listCanary(url, apiKey, sessionId, timeoutMs) {
+  const callRes = await mcpCallTool(
+    url,
+    apiKey,
+    sessionId,
+    LEGACY_CANARY_TOOL,
     {
       scope: "read",
       conversation_id: NIL_UUID,
@@ -210,7 +284,7 @@ export async function validateCanary(url, apiKey, options = {}) {
     return {
       ok: false,
       datapack_count: null,
-      step: CANARY_TOOL,
+      step: LEGACY_CANARY_TOOL,
       message: `Canary: ${callRes.message}`,
     };
   }
@@ -224,30 +298,21 @@ export async function validateCanary(url, apiKey, options = {}) {
     return {
       ok: false,
       datapack_count: null,
-      step: CANARY_TOOL,
+      step: LEGACY_CANARY_TOOL,
       message:
-        `Canary: ${CANARY_TOOL} returned an unexpected response shape ` +
+        `Canary: ${LEGACY_CANARY_TOOL} returned an unexpected response shape ` +
         `(expected a JSON array of datapack objects). Check the server logs.`,
     };
   }
 
   if (datapacks.length === 0) {
-    return {
-      ok: false,
-      datapack_count: 0,
-      step: CANARY_TOOL,
-      message:
-        `Canary: ${CANARY_TOOL} returned zero datapacks. Every authenticated ` +
-        `Meko user should have at least their default datapack — this likely ` +
-        `means the API token authenticated but resolved to the wrong tenant. ` +
-        `Verify the API key matches the tenant the URL points at.`,
-    };
+    return zeroDatapacks(LEGACY_CANARY_TOOL);
   }
 
   return {
     ok: true,
     datapack_count: datapacks.length,
-    message: `Canary OK — ${CANARY_TOOL} returned ${datapacks.length} datapack(s).`,
+    message: `Canary OK — ${LEGACY_CANARY_TOOL} returned ${datapacks.length} datapack(s).`,
   };
 }
 
@@ -263,8 +328,8 @@ export async function validateCanary(url, apiKey, options = {}) {
  * canary reuses that same session too.
  *
  * The canary is skipped (not failed) when tools/list didn't pass — the
- * canary depends on `datapack_list` being present, and a tools failure
- * already surfaces that.
+ * canary depends on `datapack_list` (a core tool) or `datapack_search`
+ * being present, and a tools failure already surfaces that.
  *
  * @param {string} url - Full MCP endpoint URL.
  * @param {string|null} apiKey - Optional API key.
@@ -292,6 +357,7 @@ export async function runValidation(url, apiKey, serverName = "meko", options =
     if (tools.ok && connectivity.ok) {
       canary = await validateCanary(url, apiKey, {
         sessionId: connectivity.sessionId,
+        toolNames: tools.tools,
       });
     } else {
       canary = {
@@ -508,6 +574,29 @@ function extractFirstText(result) {
   return null;
 }
 
+/**
+ * Parse a `datapack_search` response body and return its `datapacks` rows,
+ * or `null` if the body is not a recognizable page.
+ *
+ * @param {string|null} text
+ * @returns {Array|null}
+ */
+function parseDatapackSearchPage(text) {
+  if (!text) return null;
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!body || typeof body !== "object" || !Array.isArray(body.datapacks)) return null;
+  const rows = body.datapacks;
+  const allLookLikeDatapacks = rows.every(
+    (entry) => entry && typeof entry === "object" && typeof entry.datapack_id === "string",
+  );
+  return allLookLikeDatapacks ? rows : null;
+}
+
 /**
  * Parse a `datapack_list` response body and return the array of datapacks,
  * or `null` if the body is not a recognizable datapack list.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yugabytedb/meko-mcp",
-  "version": "2.3.0",
+  "version": "2.5.1",
   "description": "Installer for Meko across Claude, Cursor, Codex, and Kiro clients",
   "type": "module",
   "bin": {
@@ -18,11 +18,11 @@
     "prepack": "node scripts/bundle-assets.mjs",
     "postpack": "node scripts/bundle-assets.mjs --clean",
     "bundle-assets": "node scripts/bundle-assets.mjs",
-    "test": "node --test \"test/*.mjs\" && node --test \"test/serial/*.mjs\"",
+    "test": "node --import ./test/helpers/hermetic-env.mjs --test \"test/*.mjs\" && node --import ./test/helpers/hermetic-env.mjs --test \"test/serial/*.mjs\"",
     "smoke": "./scripts/prepublish-smoke.sh",
-    "test:unit": "node --test test/config.test.mjs test/validate.test.mjs test/clients.test.mjs",
-    "test:integration": "RUN_INSTALLER_INTEGRATION=1 node --test test/installer.test.mjs",
-    "test:integration:cloud": "RUN_INSTALLER_INTEGRATION=1 node --test test/installer.test.mjs"
+    "test:unit": "node --import ./test/helpers/hermetic-env.mjs --test test/config.test.mjs test/validate.test.mjs test/clients.test.mjs",
+    "test:integration": "RUN_INSTALLER_INTEGRATION=1 node --import ./test/helpers/hermetic-env.mjs --test test/installer.test.mjs",
+    "test:integration:cloud": "RUN_INSTALLER_INTEGRATION=1 node --import ./test/helpers/hermetic-env.mjs --test test/installer.test.mjs"
   },
   "engines": {
     "node": ">=20.18.1"