@xano/sdk 1.0.5 → 1.0.7

package/dist/local-engine-mcp-bridge-QKZHUGW3.js

@@ -0,0 +1,423 @@
+import {
+  isLoopbackUrl
+} from "./chunk-LCOCRJ4K.js";
+import {
+  isRecord
+} from "./chunk-MYZRMSPM.js";
+import "./chunk-L6HZ67P6.js";
+import "./chunk-MF4W6FHU.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-CH23ONYG.js";
+import "./chunk-YHB34BN6.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/deploy/local-engine-mcp-bridge.ts
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+var PROTOCOL_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+var POLL_INTERVAL_MS = 2e3;
+var CONNECT_TIMEOUT_MS = 5e3;
+var PARSE_ERROR = -32700;
+var INVALID_REQUEST = -32600;
+var INTERNAL_ERROR = -32603;
+var SERVER_ERROR = -32e3;
+var PostFailure = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+  kind;
+};
+async function runMcpBridge(opts) {
+  const bridge = new Bridge(opts);
+  try {
+    await bridge.run();
+  } catch (err) {
+    opts.log(`xano-local MCP bridge stopped: ${err.message}`);
+  }
+}
+var Bridge = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.post = opts.post ?? defaultPost;
+    this.cli = opts.cli ?? "npx xanosdk";
+  }
+  opts;
+  post;
+  cli;
+  /** The engine in use, or why there is none. Undefined until first looked up. */
+  state;
+  resolving;
+  /** The agent sent `notifications/initialized`: notifications may now be sent to it. */
+  initialized = false;
+  lastSignal;
+  /** The lookup failure last said on stderr, so one that persists is said once, not every poll. */
+  lastFailure;
+  timer;
+  pending = /* @__PURE__ */ new Set();
+  async run() {
+    try {
+      for await (const line of this.opts.lines) {
+        if (line.trim() === "") continue;
+        const handling = this.handleLine(line).catch((err) => {
+          this.opts.log(`xano-local MCP bridge: ${err.message}`);
+        });
+        this.pending.add(handling);
+        void handling.finally(() => this.pending.delete(handling));
+      }
+      await Promise.all(this.pending);
+    } finally {
+      this.stopPolling();
+    }
+  }
+  // ── messages ──────────────────────────────────────────────────────────────
+  async handleLine(line) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      this.send(errorFrame(null, PARSE_ERROR, "Parse error: the line is not JSON."));
+      return;
+    }
+    if (Array.isArray(parsed)) return this.handleBatch(parsed, line);
+    if (!isRecord(parsed)) {
+      this.send(errorFrame(null, INVALID_REQUEST, "Invalid request: expected a JSON-RPC object."));
+      return;
+    }
+    if (typeof parsed.method !== "string") {
+      if ("id" in parsed && ("result" in parsed || "error" in parsed)) {
+        this.opts.log("xano-local MCP bridge: dropped a response to a request it did not send.");
+      } else {
+        this.send(errorFrame(idOf(parsed), INVALID_REQUEST, "Invalid request: no method."));
+      }
+      return;
+    }
+    const answer = await this.handleMessage(parsed, line);
+    if (answer !== void 0) this.send(answer);
+  }
+  /** One message's answer, or undefined when it gets none (a notification). */
+  async handleMessage(msg, raw) {
+    const method = msg.method;
+    const isRequest = "id" in msg;
+    if (method === "ping") return isRequest ? { jsonrpc: "2.0", id: idOf(msg), result: {} } : void 0;
+    if (method === "notifications/initialized") this.initialized = true;
+    const state = await this.current();
+    if (method === "initialize") return this.initialize(msg, raw, state);
+    if (state.state !== "usable") return isRequest ? this.noEngineAnswer(msg, state) : void 0;
+    return this.forward(raw, msg, state);
+  }
+  async handleBatch(items, raw) {
+    const state = await this.current();
+    if (state.state === "usable" && items.every((m) => isRecord(m) && m.method !== "initialize")) {
+      const answer = await this.forward(raw, void 0, state);
+      if (answer !== void 0) this.send(answer);
+      if (answer !== void 0 || this.state?.state === "usable") return;
+    }
+    const answers = [];
+    for (const item of items) {
+      if (!isRecord(item) || typeof item.method !== "string") {
+        answers.push(errorFrame(isRecord(item) ? idOf(item) : null, INVALID_REQUEST, "Invalid request: no method."));
+        continue;
+      }
+      const answer = await this.handleMessage(item, JSON.stringify(item));
+      if (Array.isArray(answer)) answers.push(...answer);
+      else if (answer !== void 0) answers.push(answer);
+    }
+    if (answers.length > 0) this.send(answers);
+  }
+  /**
+   * The bridge's own `initialize` answer, with the engine's server info and
+   * instructions when there is an engine to ask. `listChanged` is the bridge's
+   * promise either way: it is the bridge that notices an engine come and go.
+   */
+  async initialize(msg, raw, state) {
+    const id = idOf(msg);
+    const params = isRecord(msg.params) ? msg.params : {};
+    const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : void 0;
+    const local = {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: asked !== void 0 && PROTOCOL_VERSIONS.includes(asked) ? asked : PROTOCOL_VERSIONS[0],
+        capabilities: { tools: { listChanged: true } },
+        serverInfo: { name: "xano-local", title: "Xano Engine (local, via xanosdk)", version: "1" },
+        instructions: noEngineText(state, this.cli)
+      }
+    };
+    if (state.state !== "usable") return local;
+    const answer = await this.forward(raw, msg, state);
+    if (!isRecord(answer) || !isRecord(answer.result)) return local;
+    const result = answer.result;
+    const capabilities = isRecord(result.capabilities) ? result.capabilities : {};
+    const tools = isRecord(capabilities.tools) ? capabilities.tools : {};
+    return { ...answer, result: { ...result, capabilities: { ...capabilities, tools: { ...tools, listChanged: true } } } };
+  }
+  /** The answer a request gets while there is no engine: what to do, in words the model reads. */
+  noEngineAnswer(msg, state) {
+    const id = idOf(msg);
+    const text = noEngineText(state, this.cli);
+    if (msg.method === "tools/list") return { jsonrpc: "2.0", id, result: { tools: [] } };
+    if (msg.method === "tools/call") {
+      return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text }], isError: true } };
+    }
+    return errorFrame(id, SERVER_ERROR, text);
+  }
+  // ── forwarding ────────────────────────────────────────────────────────────
+  /**
+   * POST `raw` to the engine and turn its answer into what the agent gets.
+   * `msg` is undefined for a batch. Resent once, after a fresh lookup, only when
+   * the first attempt provably did not run: refused, an HTTP 401 (no bearer
+   * reached the route), or the engine's in-band refusal of a stale bearer (the
+   * Meta API refuses it before the route runs).
+   */
+  async forward(raw, msg, state) {
+    const first = await this.attempt(raw, state);
+    if (!needsRetry(first)) return this.answerFor(first, msg);
+    const fresh = await this.refresh();
+    if (fresh.state !== "usable") return msg !== void 0 && "id" in msg ? this.noEngineAnswer(msg, fresh) : void 0;
+    return this.answerFor(await this.attempt(raw, fresh), msg);
+  }
+  async attempt(raw, state) {
+    if (state.state !== "usable") return { kind: "refused", message: "no engine" };
+    if (!isLoopbackUrl(state.mcpUrl)) {
+      return { kind: "refused", message: `the engine's MCP url is not on this machine (${state.mcpUrl})` };
+    }
+    try {
+      const reply = await this.post(
+        state.mcpUrl,
+        {
+          "content-type": "application/json",
+          accept: "application/json, text/event-stream",
+          authorization: `Bearer ${state.engine.token}`
+        },
+        raw
+      );
+      return { kind: "reply", reply, frames: parseReply(reply) };
+    } catch (err) {
+      if (err instanceof PostFailure && err.kind === "refused") return { kind: "refused", message: err.message };
+      return { kind: "unknown", message: err.message };
+    }
+  }
+  answerFor(attempt, msg) {
+    const id = msg === void 0 ? null : idOf(msg);
+    const isRequest = msg === void 0 || "id" in msg;
+    if (attempt.kind === "refused") {
+      this.opts.log(`xano-local MCP bridge: the engine refused the connection (${attempt.message}).`);
+      return isRequest ? errorFrame(id, SERVER_ERROR, `The Xano Engine is not answering. Deploy again with \`${this.cli} deploy --local\`, then retry.`) : void 0;
+    }
+    if (attempt.kind === "unknown") {
+      this.opts.log(`xano-local MCP bridge: the connection to the engine failed after sending (${attempt.message}).`);
+      if (!isRequest) return void 0;
+      const what = msg?.method === "tools/call" ? describeCall(msg) : `this ${typeof msg?.method === "string" ? msg.method : "batch"} request`;
+      return errorFrame(
+        id,
+        SERVER_ERROR,
+        `The connection to the Xano Engine failed after ${what} was sent, so whether it ran is unknown. It was not sent again. Check what it would have changed before retrying.`
+      );
+    }
+    const { reply, frames } = attempt;
+    if (reply.status === 202) return void 0;
+    if (frames === void 0) {
+      if (!isRequest) return void 0;
+      return errorFrame(id, INTERNAL_ERROR, `The Xano Engine answered HTTP ${reply.status} without a JSON-RPC message.`);
+    }
+    if (reply.status === 401 && !Array.isArray(frames) && frames.id === null && msg !== void 0) {
+      return isRequest ? { ...frames, id } : void 0;
+    }
+    return frames;
+  }
+  // ── the engine ────────────────────────────────────────────────────────────
+  /** The state, looked up on first use. */
+  async current() {
+    return this.state ?? this.refresh();
+  }
+  /** Look the engine up again; one lookup at a time, shared by whoever asks. */
+  refresh() {
+    this.resolving ??= this.lookup().finally(() => {
+      this.resolving = void 0;
+    });
+    return this.resolving;
+  }
+  async lookup() {
+    this.lastSignal = this.readSignal();
+    let found;
+    try {
+      found = await this.opts.lookup();
+      this.lastFailure = void 0;
+    } catch (err) {
+      const failure = err.message;
+      if (failure !== this.lastFailure) this.opts.log(`xano-local MCP bridge: could not look up the Xano Engine: ${failure}`);
+      this.lastFailure = failure;
+      found = { state: "not-running" };
+      this.lastSignal = void 0;
+    }
+    if (found.state === "usable") this.opts.registerSecret(found.engine.token);
+    const before = this.state;
+    this.state = found;
+    if (found.state === "usable") this.stopPolling();
+    else this.startPolling();
+    if (before !== void 0 && connectionOf(before) !== connectionOf(found)) this.notifyToolsChanged();
+    return found;
+  }
+  notifyToolsChanged() {
+    if (this.initialized) this.send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+  }
+  readSignal() {
+    try {
+      return this.opts.recordSignal();
+    } catch {
+      return void 0;
+    }
+  }
+  startPolling() {
+    if (this.timer !== void 0) return;
+    const every = this.opts.setInterval ?? ((fn, ms) => setInterval(fn, ms).unref());
+    this.timer = every(() => {
+      const signal = this.readSignal();
+      if (signal === this.lastSignal || this.resolving !== void 0) return;
+      void this.refresh();
+    }, this.opts.pollMs ?? POLL_INTERVAL_MS);
+  }
+  stopPolling() {
+    if (this.timer === void 0) return;
+    (this.opts.clearInterval ?? ((h) => clearInterval(h)))(this.timer);
+    this.timer = void 0;
+  }
+  send(frame) {
+    this.opts.write(JSON.stringify(frame));
+  }
+};
+function connectionOf(state) {
+  return state.state === "usable" ? state.mcpUrl : void 0;
+}
+function needsRetry(attempt) {
+  if (attempt.kind === "refused") return true;
+  if (attempt.kind === "unknown") return false;
+  if (attempt.reply.status === 401) return true;
+  const { frames } = attempt;
+  return frames !== void 0 && !Array.isArray(frames) && isBearerRefusal(frames);
+}
+function isBearerRefusal(frame) {
+  const result = frame.result;
+  if (!isRecord(result) || result.isError !== true || !Array.isArray(result.content)) return false;
+  return result.content.some((part) => {
+    if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string") return false;
+    try {
+      const body = JSON.parse(part.text);
+      return isRecord(body) && body.status === 401 && body.code === "ERROR_CODE_UNAUTHORIZED" && typeof body.hint === "string" && /refused this server's bearer/.test(body.hint);
+    } catch {
+      return false;
+    }
+  });
+}
+function parseReply(reply) {
+  if (/text\/event-stream/i.test(reply.contentType)) {
+    const frames = [];
+    for (const event of reply.body.split(/\r?\n\r?\n/)) {
+      const data = event.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).replace(/^ /, "")).join("\n");
+      if (data === "") continue;
+      const parsed2 = parseJson(data);
+      if (Array.isArray(parsed2)) frames.push(...parsed2.filter(isRecord));
+      else if (isRecord(parsed2)) frames.push(parsed2);
+    }
+    if (frames.length === 0) return void 0;
+    return frames.length === 1 ? frames[0] : frames;
+  }
+  const parsed = parseJson(reply.body);
+  if (Array.isArray(parsed)) return parsed.filter(isRecord);
+  return isRecord(parsed) ? parsed : void 0;
+}
+function noEngineText(state, cli) {
+  if (state.state === "usable") return "Operates the workspace deployed to the Xano Engine on this machine.";
+  const deploy = `Deploy with \`npm run xano:deploy\` (or \`${cli} deploy --local\`) and the tools appear here.`;
+  const named = state.name === void 0 ? "This project's Xano Engine" : `Xano Engine "${state.name}"`;
+  switch (state.state) {
+    case "none-cached":
+    case "not-recorded":
+      return `No Xano Engine is running for this project. ${deploy}`;
+    case "not-running":
+      return `${named} is not running.` + (state.suggestion === void 0 ? "" : ` Did you mean "${state.suggestion}"? It is running.`) + ` ${deploy}`;
+    case "no-mcp":
+      return `${named} serves no MCP server. Run \`${cli} local update\`, then deploy again, and the tools appear here.`;
+    case "not-loopback":
+      return `${named} listens beyond this machine, so its bearer is not sent to it. Stop it with \`${cli} local stop${state.name === void 0 ? "" : ` ${state.name}`}\`, then deploy again.`;
+  }
+}
+function describeCall(msg) {
+  const params = isRecord(msg.params) ? msg.params : {};
+  return typeof params.name === "string" ? `the call to ${params.name}` : "the tool call";
+}
+function errorFrame(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+function idOf(msg) {
+  const id = msg.id;
+  return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+var defaultPost = (url, headers, body) => new Promise((resolve, reject) => {
+  const target = new URL(url);
+  const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+  let connected = false;
+  const req = send(target, {
+    method: "POST",
+    // A fresh connection per request: a pooled socket the engine already
+    // closed would fail after "connecting" and read as an unknown outcome
+    // for a request that never left. On loopback the handshake is free.
+    agent: false,
+    headers: { ...headers, "content-length": Buffer.byteLength(body) }
+  });
+  const connectTimer = setTimeout(() => {
+    req.destroy(new PostFailure("refused", `could not connect within ${CONNECT_TIMEOUT_MS / 1e3}s`));
+  }, CONNECT_TIMEOUT_MS);
+  req.on("socket", (socket) => {
+    const onConnect = () => {
+      connected = true;
+      clearTimeout(connectTimer);
+    };
+    if (!socket.connecting) onConnect();
+    else socket.once("connect", onConnect);
+  });
+  req.on("error", (err) => {
+    clearTimeout(connectTimer);
+    if (err instanceof PostFailure) return reject(err);
+    const refused = !connected || err.code === "ECONNREFUSED";
+    reject(new PostFailure(refused ? "refused" : "unknown", err.message));
+  });
+  req.on("response", (res) => {
+    clearTimeout(connectTimer);
+    const chunks = [];
+    res.on("data", (c) => chunks.push(c));
+    res.on("error", (err) => reject(new PostFailure("unknown", err.message)));
+    res.on("aborted", () => reject(new PostFailure("unknown", "the answer was cut off")));
+    res.on(
+      "end",
+      () => resolve({
+        status: res.statusCode ?? 0,
+        contentType: String(res.headers["content-type"] ?? ""),
+        body: Buffer.concat(chunks).toString("utf8")
+      })
+    );
+  });
+  req.end(body);
+});
+export {
+  CONNECT_TIMEOUT_MS,
+  POLL_INTERVAL_MS,
+  PostFailure,
+  defaultPost,
+  isBearerRefusal,
+  noEngineText,
+  runMcpBridge
+};
+//# sourceMappingURL=local-engine-mcp-bridge-QKZHUGW3.js.map

package/dist/local-engine-mcp-command-BFQVLXZC.js

@@ -0,0 +1,181 @@
+import {
+  resolveLiveEngine
+} from "./chunk-YCUDOF6Q.js";
+import "./chunk-O56DQKPL.js";
+import "./chunk-QRQ54LUI.js";
+import "./chunk-NV37YGOV.js";
+import "./chunk-7M6JP3FS.js";
+import "./chunk-2SD4LA22.js";
+import "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-HZ6ADG3O.js";
+import "./chunk-FENA7K7C.js";
+import "./chunk-64WWE3EF.js";
+import "./chunk-RBU2YX22.js";
+import "./chunk-2TFRR6JV.js";
+import "./chunk-S46ODQRA.js";
+import "./chunk-TWVUYS63.js";
+import "./chunk-26LHXLD3.js";
+import "./chunk-MBL7CXJ7.js";
+import "./chunk-VNDR2T35.js";
+import "./chunk-EPFDY5JU.js";
+import "./chunk-A4R5CAY4.js";
+import "./chunk-LCOCRJ4K.js";
+import "./chunk-WNCW2RNB.js";
+import "./chunk-QGIZLFAS.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-AKERAUNH.js";
+import "./chunk-ORGNLQN6.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-PEX4QZVI.js";
+import "./chunk-MYZRMSPM.js";
+import "./chunk-UYFUIHH3.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-3FRGNBOC.js";
+import "./chunk-NDJAKSE7.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-5SCPRXFB.js";
+import "./chunk-DIWF7L33.js";
+import "./chunk-D5OZRJ3T.js";
+import "./chunk-EF4MHLEW.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-47XT6WQL.js";
+import "./chunk-DXUICABI.js";
+import "./chunk-L6HZ67P6.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-MFWF2NZJ.js";
+import {
+  detectPackageManager
+} from "./chunk-DNBP4GJN.js";
+import "./chunk-CNZASQPL.js";
+import "./chunk-WAVNUTMT.js";
+import "./chunk-ARWMVNDJ.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-HU7F56VF.js";
+import "./chunk-MF4W6FHU.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-4GPIOIAC.js";
+import "./chunk-5GIOCDUM.js";
+import "./chunk-LJM5CIY4.js";
+import {
+  MCP_CONFIGS,
+  MCP_SERVER_NAME,
+  info,
+  isMachineOutput,
+  mcpServerCommand,
+  printHuman,
+  projectFileCli,
+  writeJson
+} from "./chunk-CH23ONYG.js";
+import "./chunk-7FIMUFBP.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import "./chunk-YHB34BN6.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-5KJBWIDZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-VQPDATQT.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-LL6ED5IB.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-4MIV244X.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/local-engine-mcp-command.ts
+import { resolve } from "path";
+async function runMcp(args, opts) {
+  if (args.stdio) return runMcpStdio(args, opts);
+  if (args.project !== void 0) process.chdir(resolve(args.project));
+  const engine = await resolveLiveEngine(args.positionals[0], opts, "connect an agent to");
+  const dir = process.cwd();
+  const manager = detectPackageManager(dir, opts.env ?? process.env);
+  const server = mcpServerCommand(dir, manager);
+  if (engine.mcpUrl === void 0) {
+    info(`Xano Engine ${engine.name} serves no MCP server for coding agents; \`xanosdk local update\` moves the project to one that does.`);
+  }
+  if (isMachineOutput(args)) {
+    writeJson({
+      name: engine.name,
+      url: engine.url,
+      mcpUrl: engine.mcpUrl ?? null,
+      workspaceId: engine.workspaceId,
+      command: [server.command, ...server.args]
+    });
+    return;
+  }
+  if (engine.mcpUrl === void 0) return;
+  const labels = MCP_CONFIGS.map((c) => `${c.path} (${c.agent})`);
+  const width = Math.max(...labels.map((l) => l.length));
+  const configs = MCP_CONFIGS.map((c, i) => {
+    const block = mcpServerCommand(dir, manager, c.workspaceFolder === void 0 ? {} : { workspaceFolder: c.workspaceFolder });
+    return `  ${labels[i].padEnd(width)}  ${JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: block } })}`;
+  });
+  printHuman(
+    [
+      `Xano Engine ${engine.name}`,
+      `  URL      ${engine.url}`,
+      `  MCP      ${engine.mcpUrl}`,
+      `  Bearer   \`xanosdk local token\` (the bridge fetches it itself; never put it in a config)`,
+      `  Command  ${[server.command, ...server.args].join(" ")}`,
+      ``,
+      `Connect a coding agent with this server (\`xanosdk init\` writes each):`,
+      ...configs,
+      ``,
+      `Use it to look at the backend, seed and edit rows, and run functions, tasks, triggers, endpoints and tests.`,
+      `Tables, functions, endpoints and every other primitive change in xano/ and ship with \`xanosdk deploy\`.`
+    ].join("\n") + "\n"
+  );
+}
+async function runMcpStdio(args, opts) {
+  const log = (line) => void process.stderr.write(line + "\n");
+  for (const [signal, code] of [["SIGINT", 130], ["SIGTERM", 143], ["SIGHUP", 129]]) {
+    process.removeAllListeners(signal);
+    process.on(signal, () => {
+      log(`xano-local MCP bridge: stopped by ${signal}.`);
+      process.exit(code);
+    });
+  }
+  try {
+    if (args.project !== void 0) process.chdir(resolve(args.project));
+    const env = opts.env ?? process.env;
+    const cwd = process.cwd();
+    const name = args.positionals[0];
+    const [{ createInterface }, { runMcpBridge }, { lookupEngine }, { registerSecret, writeData }, { projectKey, readLocalEngineState }] = await Promise.all([
+      import("readline"),
+      import("./local-engine-mcp-bridge-QKZHUGW3.js"),
+      import("./local-engine-lookup-GM3E3NPP.js"),
+      import("./secrets-IV4N5HYI.js"),
+      import("./local-engine-state-JQPKGB65.js")
+    ]);
+    await runMcpBridge({
+      lines: createInterface({ input: process.stdin, crlfDelay: Infinity }),
+      // Unredacted on purpose: a frame is data the agent asked for (a row may
+      // well hold a token-shaped value), and rewriting it would corrupt it.
+      write: (frame) => void writeData(process.stdout, frame + "\n"),
+      log,
+      lookup: () => lookupEngine({ cwd, ...name === void 0 ? {} : { name }, env }),
+      // This project's row, or the rows naming the engine asked for: a deploy
+      // in another project rewrites the same file and must not cost a lookup.
+      recordSignal: () => {
+        const { engines } = readLocalEngineState(env);
+        return JSON.stringify(
+          name === void 0 ? engines[projectKey(cwd)] : Object.values(engines).filter((r) => r.name === name)
+        );
+      },
+      registerSecret,
+      // Spelled as the project's own files spell it: the reader is an agent
+      // working in the project, whatever launched this process.
+      cli: projectFileCli(cwd, detectPackageManager(cwd, env))
+    });
+  } catch (err) {
+    log(`xano-local MCP bridge stopped: ${err.message}`);
+  }
+}
+export {
+  runMcp
+};
+//# sourceMappingURL=local-engine-mcp-command-BFQVLXZC.js.map

package/dist/{local-engine-process-6YPJHKYM.js → local-engine-process-XUQPQENQ.js}

@@ -13,27 +13,29 @@ import {
   engineVersionToken,
   findOrphanedEngineProcesses,
   listEngines,
+  listEnginesAsync,
   mintEngineLoginLink,
   resolveRecordedEngine,
   startEngine,
   stopAllEngines,
   stopEngineNamed,
   stopOrphanedEngineProcesses
-} from "./chunk-RXCT3OCU.js";
-import "./chunk-Z3SNX45M.js";
+} from "./chunk-HZ6ADG3O.js";
+import "./chunk-FENA7K7C.js";
 import "./chunk-64WWE3EF.js";
-import "./chunk-JQOX6HW4.js";
-import "./chunk-Q22BMRPF.js";
-import "./chunk-PL7AIAWS.js";
+import "./chunk-RBU2YX22.js";
+import "./chunk-EPFDY5JU.js";
+import "./chunk-A4R5CAY4.js";
+import "./chunk-LCOCRJ4K.js";
 import "./chunk-ZYJP6BOO.js";
 import "./chunk-QO6BVGS5.js";
 import "./chunk-DXUICABI.js";
-import "./chunk-HLQH3AXB.js";
+import "./chunk-L6HZ67P6.js";
 import "./chunk-LLNZGEFK.js";
 import "./chunk-MF4W6FHU.js";
 import "./chunk-X2NL4KUO.js";
-import "./chunk-XNZURZ7T.js";
-import "./chunk-GPI3OWRE.js";
+import "./chunk-CH23ONYG.js";
+import "./chunk-YHB34BN6.js";
 import "./chunk-UTI5G6OJ.js";
 import "./chunk-5ZSO4T2G.js";
 import "./chunk-TFFGOFVZ.js";
@@ -54,6 +56,7 @@ export {
   engineVersionToken,
   findOrphanedEngineProcesses,
   listEngines,
+  listEnginesAsync,
   mintEngineLoginLink,
   resolveRecordedEngine,
   startEngine,
@@ -61,4 +64,4 @@ export {
   stopEngineNamed,
   stopOrphanedEngineProcesses
 };
-//# sourceMappingURL=local-engine-process-6YPJHKYM.js.map
+//# sourceMappingURL=local-engine-process-XUQPQENQ.js.map

package/dist/{local-engine-state-OCW5YDD7.js → local-engine-state-JQPKGB65.js}

@@ -11,8 +11,9 @@ import {
   projectKey,
   readLocalEngineState,
   setEngineRecord
-} from "./chunk-Q22BMRPF.js";
-import "./chunk-PL7AIAWS.js";
+} from "./chunk-EPFDY5JU.js";
+import "./chunk-A4R5CAY4.js";
+import "./chunk-LCOCRJ4K.js";
 import "./chunk-ZYJP6BOO.js";
 import "./chunk-QO6BVGS5.js";
 import "./chunk-LLNZGEFK.js";
@@ -32,4 +33,4 @@ export {
   readLocalEngineState,
   setEngineRecord
 };
-//# sourceMappingURL=local-engine-state-OCW5YDD7.js.map
+//# sourceMappingURL=local-engine-state-JQPKGB65.js.map