@xano/cli 1.0.6-beta.13 → 1.0.6-beta.15

package/dist/base-command.d.ts

@@ -15,6 +15,11 @@ export interface CredentialsFile {
     };
 }
 export declare function buildUserAgent(version: string): string;
+/**
+ * True when `error` is the "foreign dispatcher rejected by built-in fetch"
+ * failure (Node 26+). The real code lives on `error.cause.code`.
+ */
+export declare function isInvalidDispatcherError(error: unknown): boolean;
 export interface SandboxTenant {
     created_at?: string;
     description?: string;

package/dist/base-command.js

@@ -29,13 +29,46 @@ function resolveRequestTimeoutMs(env = process.env) {
         return DEFAULT_REQUEST_TIMEOUT_MS;
     return parsed;
 }
+/**
+ * Whether the built-in `fetch` on this runtime accepts a dispatcher built from
+ * our bundled userland `undici`. Node <= 24 accepts it; Node 26 rejects a
+ * foreign dispatcher with UND_ERR_INVALID_ARG, which `fetch` surfaces only as
+ * the generic "fetch failed" — breaking *every* command (DEV-7773).
+ *
+ * Starts optimistic (`true`); flipped to `false` the first time a request fails
+ * with UND_ERR_INVALID_ARG (see `verboseFetch`, which then retries without the
+ * dispatcher). Once flipped, every later request skips the dispatcher outright.
+ */
+let dispatcherSupported = true;
+/**
+ * True when `error` is the "foreign dispatcher rejected by built-in fetch"
+ * failure (Node 26+). The real code lives on `error.cause.code`.
+ */
+export function isInvalidDispatcherError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const { cause } = error;
+    const code = cause && typeof cause === 'object' && 'code' in cause
+        ? cause.code
+        : error.code;
+    return code === 'UND_ERR_INVALID_ARG';
+}
 /**
  * Lazily-built undici dispatcher whose header/body inactivity timeouts match our
  * request timeout, so undici's internal 300s default never fires first. Built
  * once and reused across requests. `timeout === 0` means "no bound".
+ *
+ * Returns `undefined` when this runtime has been found to reject a foreign
+ * dispatcher (Node 26+, DEV-7773). Dropping the dispatcher does NOT regress the
+ * large-push timeout: the per-request `AbortSignal.timeout(timeoutMs)` in
+ * `verboseFetch` already bounds the whole request (headers included) to the same
+ * 15-min ceiling the dispatcher enforced, so undici's hidden 300s
+ * `headersTimeout` is subsumed by it.
  */
 let sharedDispatcher;
 function getRequestDispatcher(timeoutMs) {
+    if (!dispatcherSupported)
+        return undefined;
     if (timeoutMs === 0) {
         sharedDispatcher ??= new Agent({ bodyTimeout: 0, headersTimeout: 0 });
         return sharedDispatcher;
@@ -324,15 +357,20 @@ export default class BaseCommand extends Command {
             ...options.headers,
         };
         const timeoutMs = resolveRequestTimeoutMs();
-        const fetchOptions = {
+        // Build the fetch options fresh each attempt: a retry needs a new
+        // AbortSignal (the first attempt's may already be aborted/consumed) and,
+        // when the dispatcher is the culprit, no dispatcher at all.
+        const buildFetchOptions = (withDispatcher) => ({
             ...options,
             // undici dispatcher: lifts the hidden 300s headers/body timeout to our bound
-            dispatcher: getRequestDispatcher(timeoutMs),
+            ...(withDispatcher ? { dispatcher: getRequestDispatcher(timeoutMs) } : {}),
             headers,
             // belt-and-suspenders hard ceiling that also covers DNS/connect stalls;
             // surfaces as a clean AbortError (see describeNetworkError). 0 = no bound.
+            // This alone bounds the whole request, so dropping the dispatcher (Node 26)
+            // does not lose the large-push timeout protection.
             ...(timeoutMs > 0 && !options.signal ? { signal: AbortSignal.timeout(timeoutMs) } : {}),
-        };
+        });
         const contentType = headers['Content-Type'] || 'application/json';
         if (verbose) {
             this.log('');
@@ -349,7 +387,26 @@ export default class BaseCommand extends Command {
             }
         }
         const startTime = Date.now();
-        const response = await fetch(url, fetchOptions);
+        let response;
+        try {
+            response = await fetch(url, buildFetchOptions(dispatcherSupported));
+        }
+        catch (error) {
+            // Node 26+ rejects our userland-undici dispatcher with UND_ERR_INVALID_ARG,
+            // surfaced only as "fetch failed" (DEV-7773). Disable it for the rest of the
+            // process and retry once without it; the AbortSignal.timeout ceiling above
+            // still bounds the request, so the large-push protection is preserved.
+            if (dispatcherSupported && isInvalidDispatcherError(error)) {
+                dispatcherSupported = false;
+                if (verbose) {
+                    this.log('  (this Node runtime rejected undici dispatcher; retrying without it — see DEV-7773)');
+                }
+                response = await fetch(url, buildFetchOptions(false));
+            }
+            else {
+                throw error;
+            }
+        }
         const elapsed = Date.now() - startTime;
         if (verbose) {
             this.log(`← ${response.status} ${response.statusText} (${elapsed}ms)`);

package/dist/utils/document-parser.js

@@ -203,6 +203,42 @@ export function resolveDocumentPath(doc, outputDir, deps) {
         // Realtime v1: realtime_trigger → realtime/trigger/{name}.xs
         return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'trigger') };
     }
+    if (doc.type === 'realtime_server_trigger') {
+        // Realtime v2. A realtime_server's connect/disconnect trigger. It references its
+        // owning server by name via `realtime_server = "..."`, so it nests under that
+        // server's folder as `<server>/trigger/`, mirroring how the server's own document
+        // and its channels already nest under realtime/server/<server>/ (DEV-7712). Keeping
+        // it there means every realtime document stays under realtime/ instead of landing at
+        // the output root. A server-less doc (a malformed/legacy export) falls back to a flat
+        // realtime/server_trigger/ under realtime/ rather than the repo root.
+        return {
+            baseName: sanitize(doc.name),
+            typeDir: doc.server
+                ? join(outputDir, 'realtime', 'server', sanitize(doc.server), 'trigger')
+                : join(outputDir, 'realtime', 'server_trigger'),
+        };
+    }
+    if (doc.type === 'channel_trigger') {
+        // Realtime v2. A channel's join/leave/deliver trigger. It references BOTH its owning
+        // server (`realtime_server = "..."`) and its channel (`channel = "..."`), so it nests
+        // beside that channel as `<server>/channel/<channel>/trigger/` — the same path the
+        // channel's own document and messages already use (DEV-7712). Falls back gracefully:
+        // channel but no resolvable server → the legacy flat channel/<path>/trigger/ layout;
+        // neither → realtime/channel_trigger/ under realtime/ (never the output root).
+        if (doc.server && doc.channel) {
+            return {
+                baseName: sanitize(doc.name),
+                typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.server), 'channel', snakeCase(doc.channel), 'trigger'),
+            };
+        }
+        if (doc.channel) {
+            return {
+                baseName: sanitize(doc.name),
+                typeDir: join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase), 'trigger'),
+            };
+        }
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'channel_trigger') };
+    }
     if (doc.type === 'realtime_server') {
         // Realtime v2. The realtime_server is the top-level container that owns
         // channels (which own messages). Its own document is named after itself

package/dist/utils/multidoc-push.js

@@ -904,6 +904,7 @@ export function describeNetworkError(error, url, elapsedMs) {
         ETIMEDOUT: `Connection to ${host} timed out. Check your network or VPN, then retry.`,
         UND_ERR_CONNECT_TIMEOUT: `Connection to ${host} timed out. Check your network or VPN, then retry.`,
         UND_ERR_HEADERS_TIMEOUT: `${host} accepted the connection but did not respond in time. The push may be too large; try splitting it or retrying.`,
+        UND_ERR_INVALID_ARG: `Your Node runtime rejected the CLI's HTTP dispatcher. Update the CLI, or run it under Node 24 (see DEV-7773).`,
     };
     let base;
     if (code && hints[code]) {