draftgo-cli 4.0.25 → 4.0.26

package/src/localRuntime/index.js

@@ -1,16 +1,17 @@
 'use strict';
 
 const { spawnSync } = require('child_process');
+const path = require('path');
 const log = require('../logger');
 const { askRequired, askPassword, confirm } = require('../prompt');
 const { probePort, probeHttp, detectDocker } = require('./detect');
 const compose = require('./compose');
 const { ensureDatabase, testConnection, describeClient } = require('./mysqlClient');
-const { defaults, portOpen, probeRedis, probeQdrant, startService } = require('./services');
+const { defaults, portOpen, probeQdrant, startService } = require('./services');
 const { writeProjectConfig } = require('../projectConfig');
-const { appendGitignoreLine } = require('../fsx');
+const { appendGitignoreLine, exists, readText } = require('../fsx');
 
-const DEFAULT_APP_PORT = 3000;
+const DEFAULT_APP_PORT = 7777;
 
 async function promptMysqlConnection() {
   while (true) {
@@ -25,10 +26,11 @@ async function promptMysqlConnection() {
   }
 }
 
-async function ensureProjectDatabase(conn, database) {
+async function ensureProjectDatabase(conn, database, interactive = true) {
   while (true) {
     const result = await ensureDatabase({ ...conn, database }, {
       rootPromptFn: async () => {
+        if (!interactive) return null;
         log.warn(`  ${conn.user} cannot create database ${database}.`);
         if (!await confirm('  Create it with another MySQL account?', { default: true })) return null;
         return {
@@ -39,13 +41,14 @@ async function ensureProjectDatabase(conn, database) {
     });
     if (result.ok) return { ...conn, database };
     log.err(`  Database setup failed: ${(result.detail || result.reason || 'unknown error').split('\n')[0]}`);
+    if (!interactive) throw new Error('Database setup needs credentials. Run `draftgo local setup` in a terminal to continue.');
     const retry = await confirm('  Re-enter MySQL connection settings?', { default: true });
     if (!retry) throw new Error('MySQL database was not prepared.');
     conn = await promptMysqlConnection();
   }
 }
 
-async function planMysql(docker, defaultDatabase) {
+async function planMysql(docker, defaultDatabase, interactive = true) {
   log.step('Checking MySQL');
   let conn = { ...defaults.mysql };
   if (!await portOpen(conn.host, conn.port)) {
@@ -54,40 +57,15 @@ async function planMysql(docker, defaultDatabase) {
   }
   if (!testConnection(conn).ok) {
     log.warn('  Default MySQL credentials were not accepted.');
+    if (!interactive) throw new Error('MySQL needs credentials. Run `draftgo local setup` in a terminal to continue.');
     conn = await promptMysqlConnection();
   }
-  const database = await askRequired('  Project database name', { default: defaultDatabase });
-  const out = await ensureProjectDatabase(conn, database);
+  const database = interactive ? await askRequired('  Project database name', { default: defaultDatabase }) : defaultDatabase;
+  const out = await ensureProjectDatabase(conn, database, interactive);
   log.ok(`  MySQL ready: ${out.host}:${out.port}/${out.database} (${describeClient()})`);
   return out;
 }
 
-async function promptRedisConnection() {
-  while (true) {
-    const host = await askRequired('  Redis host', { default: '127.0.0.1' });
-    const port = Number(await askRequired('  Redis port', { default: '6379' }));
-    const password = await askPassword('  Redis password (empty for none)', { default: '' });
-    const conn = { host, port, password };
-    if (await probeRedis(conn)) return conn;
-    log.err('  Redis PING failed. Check the address and password.');
-  }
-}
-
-async function planRedis(docker) {
-  log.step('Checking Redis');
-  let conn = { ...defaults.redis };
-  if (!await portOpen(conn.host, conn.port)) {
-    log.dim('  Redis is not running locally; starting the shared local service.');
-    if (!startService(docker, 'redis')) throw new Error('Unable to start shared Redis.');
-  }
-  if (!await probeRedis(conn)) {
-    log.warn('  Default passwordless Redis PING failed.');
-    conn = await promptRedisConnection();
-  }
-  log.ok(`  Redis ready: ${conn.host}:${conn.port}`);
-  return conn;
-}
-
 async function promptQdrantConnection() {
   while (true) {
     const host = await askRequired('  Qdrant host', { default: '127.0.0.1' });
@@ -99,7 +77,7 @@ async function promptQdrantConnection() {
   }
 }
 
-async function planQdrant(docker) {
+async function planQdrant(docker, interactive = true) {
   log.step('Checking Qdrant');
   let conn = { ...defaults.qdrant };
   if (!await portOpen(conn.host, conn.port)) {
@@ -108,15 +86,22 @@ async function planQdrant(docker) {
   }
   if (!await probeQdrant(conn)) {
     log.warn('  Default unauthenticated Qdrant REST health check failed.');
+    if (!interactive) throw new Error('Qdrant needs credentials. Run `draftgo local setup` in a terminal to continue.');
     conn = await promptQdrantConnection();
   }
   log.ok(`  Qdrant ready: ${conn.host}:${conn.port}`);
   return conn;
 }
 
-async function pickAppPort() {
+async function pickAppPort(interactive = true) {
+  if (!interactive) {
+    for (let port = DEFAULT_APP_PORT; port < DEFAULT_APP_PORT + 100; port += 1) {
+      if (!await probePort('127.0.0.1', port)) return port;
+    }
+    throw new Error('No free local port found. Run `draftgo local setup` in a terminal to select a port.');
+  }
   const taken = await probePort('127.0.0.1', DEFAULT_APP_PORT);
-  const suggested = taken ? '3001' : String(DEFAULT_APP_PORT);
+  const suggested = String(taken ? DEFAULT_APP_PORT + 1 : DEFAULT_APP_PORT);
   while (true) {
     const port = Number(await askRequired('  DraftGo host port', { default: suggested }));
     if (!Number.isInteger(port) || port < 1 || port > 65535) continue;
@@ -141,7 +126,7 @@ function composeUp(docker, dir) {
 }
 
 async function waitForApp(appPort) {
-  const ok = await probeHttp(`http://127.0.0.1:${appPort}/`, { totalMs: 120000, intervalMs: 2000 });
+  const ok = await probeHttp(`http://127.0.0.1:${appPort}/api/system/health`, { totalMs: 120000, intervalMs: 2000 });
   if (!ok) log.err('  Timed out waiting for DraftGo. Run `draftgo local logs` to inspect the app.');
   return ok;
 }
@@ -174,35 +159,50 @@ async function finishMcpSetup(projectDir, mcpCommands) {
   return setupOk && testOk;
 }
 
-async function runWizard(projectDir, { yes = false, mcpCommands } = {}) {
+async function runWizard(projectDir, { yes = false, mcpCommands, interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !yes, params = {} } = {}) {
   log.title('draftgo local setup');
+  if (!yes && !interactive) throw new Error('Run `draftgo local setup --yes` for unattended setup, or use a terminal for guided setup.');
   if (!yes && !await confirm('Continue with local DraftGo setup?', { default: true })) return 0;
 
   const docker = detectDocker();
   if (!docker.ok) {
     throw new Error(docker.reason === 'compose-missing'
-      ? 'Docker is installed but Docker Compose is unavailable.'
-      : 'Docker is required to start missing local dependencies.');
+      ? 'Install Docker Compose: https://docs.docker.com/compose/install/ then retry `draftgo local setup`.'
+      : docker.reason === 'docker-not-running'
+        ? 'Start Docker Desktop or the Docker daemon, then retry `draftgo local setup`. Installed Skills are preserved.'
+        : 'Install Docker: https://docs.docker.com/get-started/get-docker/ then start it and retry `draftgo local setup`. Installed Skills are preserved.');
   }
 
-  const appPort = await pickAppPort();
-  const projectName = await pickProjectName();
-  const mysql = await planMysql(docker, projectName);
-  const redis = await planRedis(docker);
-  const qdrant = await planQdrant(docker);
+  if (exists(compose.composePath(projectDir))) {
+    if (readText(compose.composePath(projectDir)).includes('./data/storage:/app/data/storage')) {
+      throw new Error('Existing runtime uses legacy storage. Back up and migrate it to final DraftGo before setup; Compose and data were preserved.');
+    }
+    log.dim('  Existing project runtime preserved. Use `draftgo local start` to resume it, then `draftgo connect` to bind your API Key.');
+    return 0;
+  }
+  const appPort = params.appPort || await pickAppPort(interactive);
+  const projectName = params.projectName || (interactive ? await pickProjectName() : compose.sanitizeProjectName(path.basename(projectDir)));
+  const mysql = params.mysql || await planMysql(docker, projectName, interactive);
+  const qdrant = params.qdrant === false ? null : (params.qdrant || await planQdrant(docker, interactive));
 
-  const out = compose.generate(projectDir, { projectName, appPort, mysql, redis, qdrant });
+  const out = compose.generate(projectDir, { projectName, appPort, mysql, qdrant, image: params.image });
   appendGitignoreLine(projectDir, '.draftgo/docker/');
   if (!composeUp(docker, out.dir) || !await waitForApp(appPort)) return 1;
 
   const url = `http://localhost:${appPort}`;
+  log.ok(`DraftGo runtime is ready at ${url}`);
+  log.dim('  Open the site, register or sign in, and obtain your personal API Key.');
+  if (!interactive) {
+    log.dim(`  Connection pending. Run \`draftgo connect --server ${url}\` in a terminal to enter your API Key.`);
+    return 0;
+  }
   let token = '';
   while (token.length < 10) {
     token = String(await askPassword('Paste a DraftGo user API Key')).trim();
     if (token.length < 10) log.err('  API Key appears too short. Please try again.');
   }
   const cfgPath = writeProjectConfig(projectDir, url, token);
-  await finishMcpSetup(projectDir, mcpCommands);
+  if (!await finishMcpSetup(projectDir, mcpCommands)) return 1;
   log.ok(`DraftGo is ready at ${url}`);
   log.dim(`Project config: ${cfgPath}`);
   return 0;

package/src/localRuntime/services.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Shared local runtime dependencies live outside individual projects. Project Compose
-// files only start DraftGo itself and connect back to these loopback services.
+// files run DraftGo and isolated Redis, then connect back to MySQL and Qdrant.
 const net = require('net');
 const os = require('os');
 const path = require('path');
@@ -16,17 +16,15 @@ const MYSQL_INIT_FILE = path.join(SERVICES_DIR, 'mysql-init.sql');
 
 const defaults = {
   mysql: { host: '127.0.0.1', port: 3306, user: 'draftgo', password: 'draftgo' },
-  redis: { host: '127.0.0.1', port: 6379, password: '' },
   qdrant: { host: '127.0.0.1', port: 26333, apiKey: '' },
 };
 
 function writeServiceFiles() {
   ensureDir(SERVICES_DIR);
   ensureDir(path.join(SERVICES_DIR, 'data', 'mysql'));
-  ensureDir(path.join(SERVICES_DIR, 'data', 'redis'));
   ensureDir(path.join(SERVICES_DIR, 'data', 'qdrant'));
   writeText(MYSQL_INIT_FILE, [
-    "GRANT ALL PRIVILEGES ON *.* TO 'draftgo'@'%' WITH GRANT OPTION;",
+    "GRANT ALL PRIVILEGES ON `draftgo\\_%`.* TO 'draftgo'@'%';",
     'FLUSH PRIVILEGES;',
     '',
   ].join('\n'));
@@ -54,20 +52,6 @@ function writeServiceFiles() {
     '      timeout: 5s',
     '      retries: 24',
     '      start_period: 20s',
-    '  redis:',
-    '    image: redis:7.4-alpine',
-    '    container_name: draftgo-local-redis',
-    '    restart: unless-stopped',
-    '    command: ["redis-server", "--appendonly", "yes"]',
-    '    ports:',
-    '      - "127.0.0.1:6379:6379"',
-    '    volumes:',
-    '      - ./data/redis:/data',
-    '    healthcheck:',
-    '      test: ["CMD", "redis-cli", "ping"]',
-    '      interval: 5s',
-    '      timeout: 5s',
-    '      retries: 20',
     '  qdrant:',
     '    image: qdrant/qdrant:v1.19.0',
     '    container_name: draftgo-local-qdrant',
@@ -97,26 +81,6 @@ function portOpen(host, port, timeoutMs = 800) {
   });
 }
 
-function probeRedis({ host, port, password = '' }) {
-  return new Promise((resolve) => {
-    const socket = net.createConnection({ host, port });
-    let response = '';
-    const finish = (ok) => { socket.destroy(); resolve(ok); };
-    socket.setTimeout(2000);
-    socket.once('connect', () => {
-      const auth = password ? `*2\r\n$4\r\nAUTH\r\n$${Buffer.byteLength(password)}\r\n${password}\r\n` : '';
-      socket.write(`${auth}*1\r\n$4\r\nPING\r\n`);
-    });
-    socket.on('data', (chunk) => {
-      response += chunk.toString('utf8');
-      if (response.includes('+PONG')) finish(true);
-      if (response.includes('-NOAUTH') || response.includes('-WRONGPASS') || response.includes('-ERR')) finish(false);
-    });
-    socket.once('timeout', () => finish(false));
-    socket.once('error', () => finish(false));
-  });
-}
-
 function probeQdrant({ host, port, apiKey = '' }) {
   return new Promise((resolve) => {
     const client = String(host || '').startsWith('https://') ? https : http;
@@ -148,7 +112,6 @@ module.exports = {
   SERVICES_DIR,
   defaults,
   portOpen,
-  probeRedis,
   probeQdrant,
   startService,
 };

package/src/mcp/client.js

@@ -9,30 +9,37 @@ const {
 } = require('./protocol');
 const { allWithAbort } = require('./parallel');
 
-const SAFE_TEST_TOOLS = [
-  'draftgo_project_overview',
-  'draftgo_resource_list',
-  'draftgo_api_search',
-  'draftgo_api_describe',
-  'draftgo_api_call',
-];
-
-const REQUIRED_DRAFTGO_TOOLS = [
-  'draftgo_project_overview',
-  'draftgo_resource_list',
-  'draftgo_resource_search',
-  'draftgo_resource_get_metadata',
-  'draftgo_resource_read_fragment',
-  'draftgo_api_search',
-  'draftgo_api_describe',
-  'draftgo_api_call',
-];
+const SAFE_TEST_TOOLS = [
+  'draftgo_project_overview',
+  'draftgo_resource_list',
+  'draftgo_api_search',
+  'draftgo_api_describe',
+  'draftgo_api_call',
+];
+
+const REQUIRED_DRAFTGO_TOOLS = [
+  'draftgo_api_search',
+  'draftgo_api_describe',
+  'draftgo_api_call',
+];
+
+const TOOL_ALIASES = Object.freeze({
+  draftgo_api_search: Object.freeze([
+    'draftgo_api_search', 'draftgo_operation_search', 'search_operations', 'search',
+  ]),
+  draftgo_api_describe: Object.freeze([
+    'draftgo_api_describe', 'draftgo_operation_describe', 'describe_operation', 'describe',
+  ]),
+  draftgo_api_call: Object.freeze([
+    'draftgo_api_invoke', 'draftgo_api_call', 'draftgo_operation_invoke', 'invoke_operation', 'invoke', 'call',
+  ]),
+});
 
 function diagnosticArguments(canonicalName) {
   if (canonicalName === 'draftgo_resource_list') {
     return { resource_type: 'pages', limit: 1 };
   }
-  if (canonicalName === 'draftgo_api_search') return { query: 'project', limit: 1 };
+  if (canonicalName === 'draftgo_api_search') return { query: 'listDbMeta', limit: 1 };
   return {};
 }
 
@@ -45,15 +52,35 @@ function diagnosticData(result) {
   return value;
 }
 
-function findDBMetaListOperation(result) {
-  const value = diagnosticData(result);
-  const items = value && Array.isArray(value.items) ? value.items : [];
-  return items.find((operation) => operation
-    && String(operation.method || '').toUpperCase() === 'GET'
-    && String(operation.resource_type || '').toLowerCase() === 'db_meta'
-    && String(operation.path || operation.path_template || '') === '/api/db-meta'
-    && operation.destructive !== true) || null;
-}
+const CONNECTION_PROBE_OPERATION = 'getCurrentUserAPIKey';
+
+function findConnectionProbeOperation(result) {
+  const value = diagnosticData(result);
+  const items = value && Array.isArray(value.items) ? value.items : [];
+  return items.find((operation) => operation
+    && operation.operation_id === CONNECTION_PROBE_OPERATION
+    && String(operation.method || '').toUpperCase() === 'GET'
+    && String(operation.risk || '').toLowerCase() === 'low'
+    && operation.destructive !== true) || null;
+}
+
+function assertSafeConnectionProbe(description) {
+  const value = diagnosticData(description);
+  const operation = value && value.operation && typeof value.operation === 'object'
+    ? value.operation : value;
+  const properties = operation && operation.input_schema && operation.input_schema.properties || {};
+  const required = operation && operation.input_schema && operation.input_schema.required || [];
+  const inputKeys = Object.keys(properties).filter((key) => key !== 'confirm');
+  if (!operation || operation.operation_id !== CONNECTION_PROBE_OPERATION
+      || String(operation.method || '').toUpperCase() !== 'GET'
+      || String(operation.risk || '').toLowerCase() !== 'low'
+      || operation.destructive === true || required.length > 0 || inputKeys.length > 0) {
+    throw new McpRpcError(`DraftGo Registry does not expose a safe ${CONNECTION_PROBE_OPERATION} probe.`, {
+      code: -32601,
+    });
+  }
+  return operation;
+}
 
 class McpRpcError extends Error {
   constructor(message, { code = -32000, data, id = null } = {}) {
@@ -103,40 +130,6 @@ function sessionInvalidResponse(message, expectedIds) {
     && isSessionInvalidError(item.error)) || null;
 }
 
-function diagnosticNextCursor(result) {
-  const value = diagnosticData(result);
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-  const hasMore = value.has_more === true || value.hasMore === true;
-
-  let cursor;
-  let present = false;
-  if (Object.prototype.hasOwnProperty.call(value, 'next_cursor')) {
-    cursor = value.next_cursor;
-    present = true;
-  } else if (Object.prototype.hasOwnProperty.call(value, 'nextCursor')) {
-    cursor = value.nextCursor;
-    present = true;
-  } else if (hasMore) {
-    if (!Object.prototype.hasOwnProperty.call(value, 'cursor')) {
-      throw new McpRpcError('DraftGo api_search reported more pages without a cursor.');
-    }
-    cursor = value.cursor;
-    present = true;
-  }
-
-  if (!present) return null;
-  if (cursor == null || cursor === '') {
-    if (hasMore) {
-      throw new McpRpcError('DraftGo api_search reported more pages with an empty cursor.');
-    }
-    return null;
-  }
-  if (typeof cursor !== 'string' || !cursor.trim()) {
-    throw new McpRpcError('DraftGo api_search returned an invalid cursor.');
-  }
-  return cursor;
-}
-
 function redactValue(value, secrets = [], seen = new WeakMap()) {
   if (typeof value === 'string') return redactText(value, secrets);
   if (!value || typeof value !== 'object') return value;
@@ -175,9 +168,10 @@ function findResponse(messages, id) {
     && !message.method);
 }
 
-function toolMatches(name, candidate) {
-  return name === candidate || name.endsWith(`.${candidate}`)
-    || name.endsWith(`/${candidate}`) || name.endsWith(`:${candidate}`);
+function toolMatches(name, candidate) {
+  const aliases = TOOL_ALIASES[candidate] || [candidate];
+  return aliases.some((alias) => name === alias || name.endsWith(`.${alias}`)
+    || name.endsWith(`/${alias}`) || name.endsWith(`:${alias}`));
 }
 
 class DraftGoMcpClient {
@@ -446,32 +440,20 @@ class DraftGoMcpClient {
       );
     }
 
-    const selected = safeTools.map((canonical) => ({
+    const selected = safeTools.map((canonical) => ({
       canonical,
       tool: tools.find((candidate) => candidate && typeof candidate.name === 'string'
         && toolMatches(candidate.name, canonical)),
     })).filter((entry) => entry.tool);
     const byCanonical = Object.fromEntries(selected.map((entry) => [entry.canonical, entry.tool]));
     const overrideCanonical = safeTools.find((canonical) => toolMatches(firstSafeTool.name, canonical));
-    let defaultPlan = hasDiagnosticOverrides ? [{
-      label: overrideCanonical,
-      canonical: overrideCanonical,
-      tool: firstSafeTool,
-      args: diagnosticArguments(overrideCanonical),
-    }] : [
-      { label: 'project', canonical: 'draftgo_project_overview', tool: byCanonical.draftgo_project_overview, args: {} },
-      ...['pages', 'navigations', 'docs/articles'].map((resourceType) => ({
-        label: `resource:${resourceType}`,
-        canonical: 'draftgo_resource_list',
-        tool: byCanonical.draftgo_resource_list,
-        args: { resource_type: resourceType, limit: 1 },
-      })),
-      {
-        label: 'api:db_meta',
-        canonical: 'draftgo_api_search',
-        tool: byCanonical.draftgo_api_search,
-        args: { resource_type: 'db_meta', limit: 100 },
-      },
+    const defaultPlan = hasDiagnosticOverrides ? [{
+      label: overrideCanonical,
+      canonical: overrideCanonical,
+      tool: firstSafeTool,
+      args: diagnosticArguments(overrideCanonical),
+    }] : [
+      { label: 'api:catalog', canonical: 'draftgo_api_search', tool: byCanonical.draftgo_api_search, args: { query: CONNECTION_PROBE_OPERATION, limit: 100 } },
     ];
     const runPlan = (plan, startIndex = 0) => allWithAbort(plan.map((entry, offset) =>
       async (queryOptions) => {
@@ -501,52 +483,34 @@ class DraftGoMcpClient {
       });
       }), options);
     const tested = await runPlan(defaultPlan);
-    if (!hasDiagnosticOverrides) {
-      let discovery = tested.find((entry) => entry.label === 'api:db_meta');
-      let operation = discovery && findDBMetaListOperation(discovery.result);
-      const seenCursors = new Set();
-      const maxPages = Number(options.maxPages || 100);
-      let page = 1;
-      while (!operation) {
-        const cursor = diagnosticNextCursor(discovery && discovery.result);
-        if (cursor == null) break;
-        if (seenCursors.has(cursor)) {
-          throw new McpRpcError('DraftGo api_search repeated a db_meta cursor.');
-        }
-        seenCursors.add(cursor);
-        if (page >= maxPages) {
-          throw new McpRpcError(`DraftGo api_search exceeded ${maxPages} db_meta pages.`);
-        }
-        page += 1;
-        [discovery] = await runPlan([{
-          label: `api:db_meta:page-${page}`,
-          canonical: 'draftgo_api_search',
-          tool: byCanonical.draftgo_api_search,
-          args: { resource_type: 'db_meta', limit: 100, cursor },
-        }], tested.length);
-        tested.push(discovery);
-        operation = findDBMetaListOperation(discovery.result);
-      }
-      if (!operation || !operation.operation_id) {
-        throw new McpRpcError('DraftGo MCP exposes no read-only GET /api/db-meta operation.', {
-          code: -32601,
-        });
-      }
-      const operationID = String(operation.operation_id);
-      tested.push(...await runPlan([
-        {
-          label: 'api:describe-db_meta',
-          canonical: 'draftgo_api_describe',
-          tool: byCanonical.draftgo_api_describe,
-          args: { operation_id: operationID },
-        },
-        {
-          label: 'api:call-db_meta',
-          canonical: 'draftgo_api_call',
-          tool: byCanonical.draftgo_api_call,
-          args: { operation_id: operationID, query: { page: 1, page_size: 1 } },
-        },
-      ], tested.length));
+    if (!hasDiagnosticOverrides) {
+      const discovery = tested.find((entry) => entry.label === 'api:catalog');
+      const catalog = diagnosticData(discovery && discovery.result);
+      const operation = findConnectionProbeOperation(discovery && discovery.result);
+      if (!operation || !operation.operation_id) {
+        throw new McpRpcError(`DraftGo Registry returned no safe ${CONNECTION_PROBE_OPERATION} operation.`, {
+          code: -32601,
+        });
+      }
+      const operationID = String(operation.operation_id);
+      const revision = String(catalog.registry_revision || '').trim();
+      if (!revision) {
+        throw new McpRpcError('DraftGo api_search did not return registry_revision.');
+      }
+      const [described] = await runPlan([{
+        label: 'api:describe',
+        canonical: 'draftgo_api_describe',
+        tool: byCanonical.draftgo_api_describe,
+        args: { operation_id: operationID, registry_revision: revision },
+      }], tested.length);
+      tested.push(described);
+      assertSafeConnectionProbe(described.result);
+      tested.push(...await runPlan([{
+        label: 'api:invoke',
+        canonical: 'draftgo_api_call',
+        tool: byCanonical.draftgo_api_call,
+        args: { operation_id: operationID, registry_revision: revision },
+      }], tested.length));
     }
     return {
       initialized,
@@ -580,11 +544,12 @@ module.exports = {
   McpRpcError,
   McpHttpError,
   SAFE_TEST_TOOLS,
-  REQUIRED_DRAFTGO_TOOLS,
+  REQUIRED_DRAFTGO_TOOLS,
+  TOOL_ALIASES,
   diagnosticArguments,
   diagnosticData,
-  diagnosticNextCursor,
-  findDBMetaListOperation,
+  findConnectionProbeOperation,
+  assertSafeConnectionProbe,
   isSessionInvalidError,
   redactValue,
   testConnection,

package/src/mcp/parallel.js

@@ -1,5 +1,24 @@
 'use strict';
 
+async function mapBounded(items, mapper, options = {}) {
+  const limit = options.concurrency ?? 8;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 64) throw new TypeError('Concurrency must be between 1 and 64.');
+  const results = new Array(items.length);
+  let cursor = 0;
+  async function worker() {
+    while (cursor < items.length) {
+      const index = cursor++;
+      try { results[index] = { status: 'fulfilled', value: await mapper(items[index], index) }; }
+      catch (reason) { results[index] = { status: 'rejected', reason }; }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  if (options.settled) return results;
+  const failure = results.find((item) => item.status === 'rejected');
+  if (failure) throw failure.reason;
+  return results.map((item) => item.value);
+}
+
 async function allWithAbort(taskFactories, options = {}) {
   if (!Array.isArray(taskFactories) || taskFactories.some((task) => typeof task !== 'function')) {
     throw new TypeError('Parallel MCP tasks must be functions.');
@@ -19,7 +38,11 @@ async function allWithAbort(taskFactories, options = {}) {
   }
   try {
     const taskOptions = { ...options, signal: controller.signal };
-    return await Promise.all(taskFactories.map((task) => task(taskOptions)));
+    return await mapBounded(taskFactories, async (task) => {
+      controller.signal.throwIfAborted();
+      try { return await task(taskOptions); }
+      catch (error) { controller.abort(error); throw error; }
+    }, options);
   } catch (error) {
     if (!controller.signal.aborted) controller.abort(error);
     throw error;
@@ -28,4 +51,4 @@ async function allWithAbort(taskFactories, options = {}) {
   }
 }
 
-module.exports = { allWithAbort };
+module.exports = { allWithAbort, mapBounded };