@base44-preview/cli 0.1.32-pr.663.57b7b28 → 0.1.32-pr.663.d960536

package/README.md

@@ -43,8 +43,9 @@ The CLI will guide you through project setup. For step-by-step tutorials, see th
 
 | Command | Description |
 | ------- | ----------- |
+| `api catalog [area]` | List the API's areas, or every operation in one area |
 | `api search <text>` | Search every public Base44 API operation by what it does |
-| `api grep <pattern>` | Search the raw API spec with a regular expression |
+| `api grep <pattern>` | Search the raw API spec with a regular expression; `--area` narrows it to one area |
 | `api fetch <METHOD> <path>` | Call any public Base44 API operation, like curl; `--help` after a path prints its contract |
 | [`create`](https://docs.base44.com/developers/references/cli/commands/create) | Create a new Base44 project from a template |
 | [`deploy`](https://docs.base44.com/developers/references/cli/commands/deploy) | Deploy all project resources and site to Base44 |

package/dist/cli/index.js

@@ -248042,28 +248042,6 @@ function getAgentsCommand() {
   return new Command2("agents").description("Manage project agents").addCommand(getAgentsPushCommand()).addCommand(getAgentsPullCommand());
 }
 
-// src/core/api-spec/body.ts
-var METHODS_WITHOUT_BODY = new Set(["GET", "HEAD"]);
-async function resolveRequestBody(method, flag, source) {
-  const takesBody = !METHODS_WITHOUT_BODY.has(method.toUpperCase());
-  if (flag !== undefined && !takesBody) {
-    throw new InvalidInputError(`${method.toUpperCase()} requests cannot have a body.`);
-  }
-  if (flag === "@-") {
-    return source.readStdin();
-  }
-  if (flag?.startsWith("@")) {
-    return readTextFile(flag.slice(1));
-  }
-  if (flag !== undefined) {
-    return flag;
-  }
-  if (!takesBody || source.stdinIsTTY) {
-    return;
-  }
-  const piped = await source.readStdin();
-  return piped.trim() ? piped : undefined;
-}
 // ../../node_modules/minisearch/dist/es/index.js
 var ENTRIES = "ENTRIES";
 var KEYS = "KEYS";
@@ -249164,6 +249142,38 @@ function searchOperations(operations, query, options = {}) {
   });
 }
 
+// src/core/api-spec/catalog.ts
+var INLINE_AREA_MAX = 2;
+var AREA_SAMPLE_MAX = 3;
+var byCodePoint = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function areaOf(path) {
+  const parts = path.split("/").filter(Boolean);
+  const appIdIndex = parts.indexOf("{app_id}");
+  if (appIdIndex !== -1 && appIdIndex + 1 < parts.length) {
+    return parts[appIdIndex + 1] ?? "other";
+  }
+  if (parts[0] === "api" && parts.length > 1) {
+    return parts[1] ?? "other";
+  }
+  return parts[0] ?? "other";
+}
+function groupByArea(operations) {
+  const sorted = [...operations].sort((a, b) => byCodePoint(`${a.method} ${a.path}`, `${b.method} ${b.path}`));
+  const areas = new Map;
+  for (const op of sorted) {
+    const area = areaOf(op.path);
+    areas.set(area, [...areas.get(area) ?? [], op]);
+  }
+  return new Map([...areas].sort(([a], [b]) => byCodePoint(a, b)));
+}
+function catalogIndex(operations) {
+  const areas = [...groupByArea(operations)].map(([area, ops]) => ops.length <= INLINE_AREA_MAX ? { area, operations: ops.map(toOperationSummary) } : {
+    area,
+    operationCount: ops.length,
+    sample: ops.slice(0, AREA_SAMPLE_MAX).map((op) => op.summary)
+  });
+  return { areas, total: operations.length };
+}
 // src/core/api-spec/grep.ts
 var CONTEXT_CHARS = 40;
 var MAX_SNIPPETS = 3;
@@ -249183,13 +249193,15 @@ function snippets(text, pattern) {
 function grepSpec(spec, operations, pattern, options = {}) {
   const regex = new RegExp(pattern, options.ignoreCase ? "gi" : "g");
   const hits = [];
-  for (const op of operations) {
+  const inArea = (op) => options.area === undefined || areaOf(op.path) === options.area;
+  for (const op of operations.filter(inArea)) {
     const matches = snippets(`${op.method} ${op.path} ${JSON.stringify(op.operation)}`, regex);
     if (matches.length > 0) {
       hits.push({ ...toOperationSummary(op), matches });
     }
   }
-  for (const [schema, definition] of Object.entries(spec.components?.schemas ?? {})) {
+  const schemas = options.area === undefined ? spec.components?.schemas : {};
+  for (const [schema, definition] of Object.entries(schemas ?? {})) {
     const matches = snippets(JSON.stringify(definition), regex);
     if (matches.length > 0) {
       hits.push({ schema, matches });
@@ -249437,6 +249449,56 @@ function loadSpecTask({ runTask }, refresh) {
     successMessage: "Loaded the API spec"
   });
 }
+function operationsInArea(operations, area) {
+  const areas = groupByArea(operations);
+  const inArea = areas.get(area);
+  if (!inArea) {
+    throw new InvalidInputError(`Unknown API area: ${area}`, {
+      details: [`Areas: ${[...areas.keys()].join(", ")}`],
+      hints: [{ message: "List the areas", command: "base44 api catalog" }]
+    });
+  }
+  return inArea;
+}
+async function readRequestBody(method, flag) {
+  if (flag === "@-") {
+    return readStdin("--body @-", { trim: false });
+  }
+  if (flag?.startsWith("@")) {
+    return readTextFile(flag.slice(1));
+  }
+  if (flag !== undefined) {
+    return flag;
+  }
+  if (method === "GET" || method === "HEAD" || process.stdin.isTTY) {
+    return;
+  }
+  const piped = await readStdin("--body", { trim: false });
+  return piped.trim() ? piped : undefined;
+}
+
+// src/cli/commands/api/catalog.ts
+async function catalogAction(ctx, area, options) {
+  const { spec } = await loadSpecTask(ctx, options.refresh);
+  const operations = listOperations(spec);
+  if (area === undefined) {
+    return { stdout: formatJson(catalogIndex(operations)) };
+  }
+  const inArea = operationsInArea(operations, area);
+  return {
+    stdout: formatJson({
+      area,
+      operations: inArea.map(toOperationSummary),
+      total: inArea.length
+    })
+  };
+}
+function getApiCatalogCommand() {
+  return new Base44Command("catalog", {
+    requireAuth: false,
+    requireAppContext: false
+  }).description("List the API's areas, or every operation in one area").argument("[area]", 'An area from the list, e.g. "workflows"').option("--refresh", REFRESH_OPTION_HELP).action(catalogAction);
+}
 
 // src/cli/commands/api/fetch.ts
 async function findOperation(ctx, method, path, refresh) {
@@ -249462,12 +249524,6 @@ async function fetchAction(ctx, methodArg, path, options, command) {
     throw new InvalidInputError("Provide a method and a path, e.g. GET /api/apps.");
   }
   const method = methodArg.toUpperCase();
-  if (!HTTP_METHODS.some((m) => m.toUpperCase() === method)) {
-    throw new InvalidInputError(`Unknown HTTP method: ${methodArg}`);
-  }
-  if (!path.startsWith("/")) {
-    throw new InvalidInputError(`The path must start with "/", got ${path}.`);
-  }
   if (options.help) {
     const { spec, op } = await findOperation(ctx, method, path, options.refresh);
     return { stdout: formatJson(getOperationContract(spec, op)) };
@@ -249478,11 +249534,8 @@ async function fetchAction(ctx, methodArg, path, options, command) {
       throw new InvalidInputError(`Refused under --read-only: ${op.method} ${op.path} is not a read-only operation. Nothing was sent.`);
     }
   }
-  const body = await resolveRequestBody(method, options.body, {
-    stdinIsTTY: Boolean(process.stdin.isTTY),
-    readStdin: () => readStdin("--body @-", { trim: false })
-  });
   await ensureAuth(ctx);
+  const body = await readRequestBody(method, options.body);
   const text = await ctx.runTask(`Calling ${method} ${path}`, () => sendApiRequest(method, path, body), { successMessage: `Called ${method} ${path}` });
   return { stdout: formatResponseBody(text) };
 }
@@ -249505,7 +249558,12 @@ async function grepAction(ctx, pattern, options) {
   const limit = parseLimit(options.limit);
   assertValidRegex(pattern);
   const { spec } = await loadSpecTask(ctx, options.refresh);
-  const hits = grepSpec(spec, listOperations(spec), pattern, {
+  const operations = listOperations(spec);
+  if (options.area !== undefined) {
+    operationsInArea(operations, options.area);
+  }
+  const hits = grepSpec(spec, operations, pattern, {
+    area: options.area,
     ignoreCase: options.ignoreCase,
     limit
   });
@@ -249515,7 +249573,7 @@ function getApiGrepCommand() {
   return new Base44Command("grep", {
     requireAuth: false,
     requireAppContext: false
-  }).description("Search the raw API spec with a regular expression, for when search misses").argument("<pattern>", 'Regular expression, e.g. "runs.*status"').option("-i, --ignore-case", "Case-insensitive match").option("--limit <n>", "Most operations or schemas to return (default 20)").option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
+  }).description("Search the raw API spec with a regular expression, for when search misses").argument("<pattern>", 'Regular expression, e.g. "runs.*status"').option("--area <area>", "Search only one area's operations (see base44 api catalog)").option("-i, --ignore-case", "Case-insensitive match").option("--limit <n>", "Most operations or schemas to return (default 20)").option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
 }
 
 // src/cli/commands/api/search.ts
@@ -249537,7 +249595,7 @@ function getApiSearchCommand() {
 
 // src/cli/commands/api/index.ts
 function getApiCommand() {
-  return new Command2("api").description("Search and call any public Base44 API operation").addCommand(getApiSearchCommand()).addCommand(getApiGrepCommand()).addCommand(getApiFetchCommand());
+  return new Command2("api").description("Search and call any public Base44 API operation").addCommand(getApiCatalogCommand()).addCommand(getApiSearchCommand()).addCommand(getApiGrepCommand()).addCommand(getApiFetchCommand());
 }
 
 // src/cli/commands/auth/password-login.ts
@@ -254901,6 +254959,12 @@ var deno2 = Object.freeze({
 });
 globalThis.Deno = deno2;
 globalThis.Buffer = Buffer2;
+try {
+  new AsyncLocalStorage().enterWith(void 0);
+} catch {
+  AsyncLocalStorage.prototype.enterWith = () => {
+  };
+}
 function getRegisteredHandler() {
   return registeredHandler;
 }
@@ -257866,7 +257930,7 @@ var TELEMETRY_PATCH = [
 var TELEMETRY_STORE_FIELDS = "reqId: crypto.randomUUID(), respondedAt: null, inflight: new Map(), inflightTotal: 0, hadRejection: false, hadNonOk: false, logBudget: 5";
 
 // ../functions-compiler/src/version.ts
-var COMPILER_VERSION = "0.1.7";
+var COMPILER_VERSION = "0.1.8";
 
 // ../functions-compiler/src/worker-entry.ts
 function denoShimSource() {
@@ -262490,6 +262554,174 @@ function runtimeVirtualPlugin() {
   };
 }
 
+// ../functions-compiler/src/esbuild/ws-native-virtual.ts
+var NAMESPACE4 = "base44-ws-native";
+var WS_SPECIFIER = /^(npm:)?ws(@[^/]+)?$/;
+var ADAPTER = `"use strict";
+const toBuffer = (value) => (globalThis.Buffer ? globalThis.Buffer.from(value) : value);
+const READY_STATES = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+const later = (fn, ...args) => queueMicrotask(() => fn(...args));
+const upgradeHeaders = (options) => {
+  const headers = new Headers(options?.headers);
+  for (const name of headers.keys()) if (name !== "user-agent") return headers;
+  return null;
+};
+class WebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  #socket = null;
+  #state = 0;
+  #url;
+  #closeRequested = null;
+  #terminated = false;
+  #listeners = new Map();
+  constructor(address, protocols, options) {
+    if (protocols && typeof protocols === "object" && !Array.isArray(protocols)) {
+      options = protocols;
+      protocols = undefined;
+    }
+    this.#url = String(address);
+    const headers = upgradeHeaders(options);
+    if (headers) {
+      this.#upgrade(headers, protocols);
+    } else {
+      this.#attach(new globalThis.WebSocket(this.#url, protocols));
+    }
+  }
+  get readyState() {
+    if (this.#terminated) return 3;
+    return this.#socket ? this.#socket.readyState : this.#state;
+  }
+  get url() { return this.#url; }
+  get protocol() { return this.#socket ? this.#socket.protocol ?? "" : ""; }
+  on(name, listener) { return this.#add(name, listener, false); }
+  addListener(name, listener) { return this.#add(name, listener, false); }
+  once(name, listener) { return this.#add(name, listener, true); }
+  off(name, listener) { return this.removeListener(name, listener); }
+  removeListener(name, listener) {
+    const listeners = this.#listeners.get(name);
+    if (listeners) this.#listeners.set(name, listeners.filter((entry) => entry.listener !== listener));
+    return this;
+  }
+  removeAllListeners(name) {
+    if (name === undefined) this.#listeners.clear();
+    else this.#listeners.delete(name);
+    return this;
+  }
+  emit(name, ...args) {
+    const listeners = this.#listeners.get(name) ?? [];
+    this.#listeners.set(name, listeners.filter((entry) => !entry.once));
+    for (const entry of listeners) entry.listener.apply(this, args);
+    return listeners.length > 0;
+  }
+  send(data, options, callback) {
+    const done = typeof options === "function" ? options : callback;
+    try {
+      if (!this.#socket) {
+        throw new Error("WebSocket is not open: readyState " + this.#state + " (" + READY_STATES[this.#state] + ")");
+      }
+      this.#socket.send(data);
+      done?.();
+    } catch (error) {
+      if (!done) throw error;
+      done(error);
+    }
+  }
+  close(code, reason) {
+    if (this.#socket) this.#socket.close(code, reason);
+    else if (this.#state === 0) {
+      // Upgrade still in flight: close as soon as it lands.
+      this.#closeRequested = [code, reason];
+      this.#state = 2;
+    }
+  }
+  // \`ws\` tears the connection down at once. workerd has no abrupt close, so the
+  // socket is closed normally and "close" is reported now, not on the reply.
+  terminate() {
+    if (this.#terminated || this.readyState === 3) return;
+    this.#terminated = true;
+    if (this.#socket) {
+      try { this.#socket.close(); } catch {}
+    } else {
+      // Upgrade still in flight: close it on arrival, without an "open".
+      this.#closeRequested = [];
+      this.#state = 3;
+    }
+    later(() => this.emit("close", 1006, toBuffer("")));
+  }
+  #attach(socket) {
+    this.#socket = socket;
+    try { socket.binaryType = "arraybuffer"; } catch {}
+    socket.addEventListener("open", () => this.emit("open"));
+    socket.addEventListener("message", (event) => {
+      const isBinary = typeof event.data !== "string";
+      this.emit("message", toBuffer(isBinary ? new Uint8Array(event.data) : event.data), isBinary);
+    });
+    socket.addEventListener("error", (event) => this.emit("error", event.error ?? new Error(event.message || "WebSocket error")));
+    socket.addEventListener("close", (event) => {
+      if (!this.#terminated) this.emit("close", event.code, toBuffer(event.reason ?? ""));
+    });
+  }
+  #upgrade(headers, protocols) {
+    headers.set("Upgrade", "websocket");
+    if (protocols) headers.set("Sec-WebSocket-Protocol", [].concat(protocols).join(", "));
+    const httpUrl = this.#url.replace(/^ws(s?):/i, "http$1:");
+    const fail = (error) => {
+      this.#state = 3;
+      if (this.#terminated) return;
+      this.emit("error", error);
+      this.emit("close", 1006, toBuffer(""));
+    };
+    // Two-argument then(): an exception from an "open" listener must not be
+    // reported as a failed upgrade.
+    fetch(httpUrl, { headers }).then((response) => {
+      const socket = response.webSocket;
+      if (!socket) {
+        response.body?.cancel();
+        return fail(new Error("Unexpected server response: " + response.status));
+      }
+      socket.accept();
+      this.#attach(socket);
+      if (this.#closeRequested) return socket.close(...this.#closeRequested);
+      // accept() opens the socket without dispatching an "open" event.
+      this.emit("open");
+    }, fail);
+  }
+  #add(name, listener, once) {
+    const listeners = this.#listeners.get(name) ?? [];
+    listeners.push({ listener, once });
+    this.#listeners.set(name, listeners);
+    return this;
+  }
+}
+class WebSocketServer {
+  constructor() {
+    throw new Error("ws WebSocketServer is not available in Base44 functions: a function can open WebSocket connections but cannot listen for them.");
+  }
+}
+module.exports = WebSocket;
+module.exports.WebSocket = WebSocket;
+module.exports.WebSocketServer = WebSocketServer;
+module.exports.default = WebSocket;
+`;
+function wsNativeVirtualPlugin() {
+  return {
+    name: "base44-ws-native",
+    setup(build) {
+      build.onResolve({ filter: WS_SPECIFIER }, () => ({
+        path: "ws",
+        namespace: NAMESPACE4
+      }));
+      build.onLoad({ filter: /.*/, namespace: NAMESPACE4 }, () => ({
+        contents: ADAPTER,
+        loader: "js"
+      }));
+    }
+  };
+}
+
 // ../functions-compiler/src/deno-bundle.ts
 async function bundleToModule(prepared, nodeModulesDir = "none") {
   const dir = await mkdtemp(path21.join(tmpdir2(), "b44-bundle-"));
@@ -262513,6 +262745,7 @@ async function bundleToModule(prepared, nodeModulesDir = "none") {
         sourcemap: false,
         logLevel: "silent",
         plugins: [
+          wsNativeVirtualPlugin(),
           nodeBuiltinRequirePlugin(),
           userFilesPlugin(prepared.files, prepared.entry),
           privateDataSourcesVirtualPlugin(),
@@ -272902,4 +273135,4 @@ export {
   runCLI
 };
 
-//# debugId=FA1E97B3DE15B20C64756E2164756E21
+//# debugId=6956BED77F56E7A964756E2164756E21