@xano/cli 1.0.6-beta.7 → 1.0.6-beta.9

package/dist/commands/ephemeral/push/index.d.ts

@@ -16,10 +16,20 @@ export default class EphemeralPush extends BaseCommand {
         sync: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         transaction: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         truncate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'wait-timeout': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * Poll GET .../tenant/{name}/microservice until auto microservices settle.
+     * Renders a one-line-per-microservice progress view that updates in place, then
+     * exits non-zero if any auto microservice failed or the wait timed out.
+     */
+    private waitForDeploy;
+    /** Number of lines the last progress render wrote (for in-place TTY updates). */
+    private lastRenderLines;
 }

package/dist/commands/ephemeral/push/index.js

@@ -2,6 +2,7 @@ import { Args, Flags } from '@oclif/core';
 import * as fs from 'node:fs';
 import { resolve } from 'node:path';
 import BaseCommand from '../../../base-command.js';
+import { isAwaited, waitForMicroservices, } from '../../../utils/microservice-wait.js';
 import { executePush } from '../../../utils/multidoc-push.js';
 export default class EphemeralPush extends BaseCommand {
     static args = {
@@ -88,6 +89,17 @@ Skip preview and push immediately
             description: '[CRITICAL] STOP and confirm with the user; this truncates live tables before importing.',
             required: false,
         }),
+        wait: Flags.boolean({
+            default: false,
+            description: 'After pushing, wait for auto-deployed microservices (tenant_deploy="auto") to become ready. Exits non-zero if any fails to deploy or the wait times out. Ignored with --dry-run.',
+            required: false,
+        }),
+        'wait-timeout': Flags.integer({
+            default: 300,
+            description: 'Seconds to wait for microservices to become ready when --wait is set (default 300).',
+            min: 1,
+            required: false,
+        }),
         workspace: Flags.string({
             char: 'w',
             description: 'Workspace ID (uses profile workspace if not provided)',
@@ -140,5 +152,70 @@ Skip preview and push immediately
             inputDir,
             verboseFetch: this.verboseFetch.bind(this),
         }, target, pushFlags);
+        // --wait: after a real push, poll the tenant's live microservice status until
+        // every auto-deployed microservice (tenant_deploy="auto") is ready or the
+        // wait times out. Skipped on --dry-run (nothing was deployed).
+        if (flags.wait && !flags['dry-run']) {
+            await this.waitForDeploy(baseUrl, profile.access_token, tenantName, flags['wait-timeout'], flags.verbose);
+        }
+    }
+    /**
+     * Poll GET .../tenant/{name}/microservice until auto microservices settle.
+     * Renders a one-line-per-microservice progress view that updates in place, then
+     * exits non-zero if any auto microservice failed or the wait timed out.
+     */
+    async waitForDeploy(baseUrl, accessToken, tenantName, timeoutSeconds, verbose) {
+        this.log('');
+        this.log(`Waiting for microservices to deploy (timeout ${timeoutSeconds}s)…`);
+        const icon = (e) => {
+            if (!isAwaited(e))
+                return '➖';
+            switch (e.status) {
+                case 'error': {
+                    return '❌';
+                }
+                case 'ok': {
+                    return '✅';
+                }
+                default: {
+                    return '⏳';
+                }
+            }
+        };
+        const line = (e) => {
+            const detail = isAwaited(e) ? e.detail || e.status : `skipped (${e.tenant_deploy ?? 'manual'})`;
+            return `  ${icon(e)} ${e.name.padEnd(24)} ${detail}`;
+        };
+        const result = await waitForMicroservices({
+            accessToken,
+            onPoll: (entries) => {
+                // Re-render the block: move the cursor up over the previous render (if any)
+                // and rewrite. Falls back to plain appends when not a TTY.
+                if (process.stdout.isTTY && this.lastRenderLines > 0) {
+                    process.stdout.write(`[${this.lastRenderLines}A`);
+                }
+                const lines = entries.map((e) => line(e));
+                for (const l of lines)
+                    this.log(l);
+                this.lastRenderLines = process.stdout.isTTY ? lines.length : 0;
+            },
+            statusUrl: `${baseUrl}/microservice`,
+            timeoutMs: timeoutSeconds * 1000,
+            verbose,
+            verboseFetch: this.verboseFetch.bind(this),
+        });
+        const awaited = result.entries.filter((e) => isAwaited(e));
+        const ready = awaited.filter((e) => e.status === 'ok').length;
+        if (result.timedOut) {
+            this.error(`Timed out after ${timeoutSeconds}s waiting for microservices (${ready}/${awaited.length} ready). ` +
+                `Check status with the Xano dashboard or re-run with a larger --wait-timeout.`);
+        }
+        if (result.hadError) {
+            const failed = awaited.filter((e) => e.status === 'error').map((e) => `${e.name} (${e.detail || 'error'})`);
+            this.error(`Microservice deploy failed: ${failed.join(', ')}`);
+        }
+        this.log(`All microservices ready (${ready}/${awaited.length}).`);
     }
+    /** Number of lines the last progress render wrote (for in-place TTY updates). */
+    lastRenderLines = 0;
 }

package/dist/utils/microservice-wait.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Poll a tenant's microservice deployment status until every auto-deployed
+ * microservice settles (ok/error) or a timeout elapses. Backs `ephemeral push
+ * --wait`: after a multidoc push auto-deploys microservices (tenant_deploy=
+ * "auto"), the CLI waits here for them to become Ready and reports the outcome.
+ *
+ * The backend route (GET .../tenant/{name}/microservice, statement
+ * mvp:microservice_status_all) returns one entry per microservice with a live
+ * k8s readiness read. `manual`/`disabled` microservices are reported but not
+ * waited on (they were never deployed by the push).
+ */
+/** One microservice's status as returned by the tenant status route. */
+export interface MicroserviceStatusEntry {
+    desired?: number;
+    detail?: string;
+    microservice_id: number;
+    name: string;
+    ready?: number;
+    status: string;
+    tenant_deploy?: string;
+}
+export interface WaitOptions {
+    /** Bearer token for the authed status GET. */
+    accessToken: string;
+    /** Called once per poll with the latest entries, for progress rendering. */
+    onPoll?: (entries: MicroserviceStatusEntry[], elapsedMs: number) => void;
+    /** Poll cadence in ms (default 2000). */
+    pollIntervalMs?: number;
+    /** Absolute URL of the tenant microservice status route. */
+    statusUrl: string;
+    /** Overall wait budget in ms (default 300000 = 300s). */
+    timeoutMs?: number;
+    /** Authed fetch (command.verboseFetch bound), so TLS/dispatcher settings apply. */
+    verboseFetch: (url: string, options: RequestInit, verbose: boolean, authToken?: string) => Promise<Response>;
+    /** Verbose request logging passthrough. */
+    verbose?: boolean;
+}
+export interface WaitResult {
+    /** The final status entries observed. */
+    entries: MicroserviceStatusEntry[];
+    /** True if any awaited (auto) microservice ended in "error". */
+    hadError: boolean;
+    /** True if the wait budget elapsed before all awaited microservices settled. */
+    timedOut: boolean;
+}
+/** An awaited microservice is one that was auto-deployed and is not skipped/disabled. */
+export declare function isAwaited(entry: MicroserviceStatusEntry): boolean;
+/**
+ * Poll until all awaited microservices settle or the timeout elapses. Transient
+ * poll failures (network blips, a brief 5xx while a pod restarts) are tolerated —
+ * they don't abort the wait; only the overall timeout does.
+ */
+export declare function waitForMicroservices(opts: WaitOptions): Promise<WaitResult>;

package/dist/utils/microservice-wait.js

@@ -0,0 +1,83 @@
+/**
+ * Poll a tenant's microservice deployment status until every auto-deployed
+ * microservice settles (ok/error) or a timeout elapses. Backs `ephemeral push
+ * --wait`: after a multidoc push auto-deploys microservices (tenant_deploy=
+ * "auto"), the CLI waits here for them to become Ready and reports the outcome.
+ *
+ * The backend route (GET .../tenant/{name}/microservice, statement
+ * mvp:microservice_status_all) returns one entry per microservice with a live
+ * k8s readiness read. `manual`/`disabled` microservices are reported but not
+ * waited on (they were never deployed by the push).
+ */
+/** Statuses that mean an awaited microservice has settled (no longer in flight). */
+const SETTLED = new Set(['ok', 'error']);
+/** Statuses that mean we don't wait on this microservice at all. */
+const NOT_AWAITED = new Set(['skipped', 'disabled']);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** An awaited microservice is one that was auto-deployed and is not skipped/disabled. */
+export function isAwaited(entry) {
+    return !NOT_AWAITED.has(entry.status) && (entry.tenant_deploy ?? 'auto') !== 'manual';
+}
+/** True once every awaited microservice has settled (ok/error). */
+function allSettled(entries) {
+    const awaited = entries.filter((e) => isAwaited(e));
+    // No auto microservices at all → nothing to wait for.
+    if (awaited.length === 0)
+        return true;
+    return awaited.every((e) => SETTLED.has(e.status));
+}
+/**
+ * Fetch the status route once. Throws on a non-2xx so the caller can decide
+ * whether a transient failure is fatal (it isn't — we keep polling).
+ */
+async function fetchStatus(opts) {
+    const res = await opts.verboseFetch(opts.statusUrl, { headers: { Authorization: `Bearer ${opts.accessToken}` }, method: 'GET' }, opts.verbose ?? false, opts.accessToken);
+    if (!res.ok) {
+        throw new Error(`status ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    if (!Array.isArray(body)) {
+        throw new Error('unexpected status response shape');
+    }
+    return body;
+}
+/**
+ * Poll until all awaited microservices settle or the timeout elapses. Transient
+ * poll failures (network blips, a brief 5xx while a pod restarts) are tolerated —
+ * they don't abort the wait; only the overall timeout does.
+ */
+export async function waitForMicroservices(opts) {
+    const pollIntervalMs = opts.pollIntervalMs ?? 2000;
+    const timeoutMs = opts.timeoutMs ?? 300000;
+    const start = Date.now();
+    let entries = [];
+    let consecutiveErrors = 0;
+    // Poll loop. We always do at least one fetch so `--wait` reports even when the
+    // deployment already settled between the push returning and the first poll.
+    for (;;) {
+        const elapsed = Date.now() - start;
+        try {
+            entries = await fetchStatus(opts);
+            consecutiveErrors = 0;
+            opts.onPoll?.(entries, elapsed);
+            if (allSettled(entries)) {
+                return { entries, hadError: entries.some((e) => isAwaited(e) && e.status === 'error'), timedOut: false };
+            }
+        }
+        catch {
+            // A transient status read failure is non-fatal — keep polling until the
+            // overall timeout. (Mirrors the frontend poller's tolerate-with-cap.) We
+            // don't surface each blip; the timeout is the real failure signal.
+            consecutiveErrors++;
+        }
+        if (Date.now() - start + pollIntervalMs > timeoutMs) {
+            // Out of budget. Report whatever we last saw as timed out.
+            return {
+                entries,
+                hadError: entries.some((e) => isAwaited(e) && e.status === 'error'),
+                timedOut: true,
+            };
+        }
+        await sleep(pollIntervalMs);
+    }
+}