@yugabytedb/meko-mcp 2.2.0 → 2.5.0

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.2.0",
+  "version": "2.5.0",
   "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"

package/scripts/bundle-assets.mjs

@@ -30,6 +30,10 @@ const PAYLOAD = [
     from: join(repoRoot, "skills", "hooks-handlers"),
     to: join(assetsDir, "hooks-handlers"),
   },
+  {
+    from: join(repoRoot, "skills", "opencode-plugin"),
+    to: join(assetsDir, "opencode-plugin"),
+  },
   {
     from: join(repoRoot, "skills", "scripts", "package-desktop-skill.sh"),
     to: join(assetsDir, "scripts", "package-desktop-skill.sh"),