@xano/cli 1.0.6-beta.9 → 1.2.0

package/dist/commands/ephemeral/static_host/list/index.js

@@ -1,132 +0,0 @@
-import { Args, Flags } from '@oclif/core';
-import BaseCommand from '../../../../base-command.js';
-import { buildPagingJson, buildPagingParams, formatPagingFooter, normalizeListResponse, pagingFlags } from '../../../../utils/paging.js';
-export default class EphemeralStaticHostList extends BaseCommand {
-    static args = {
-        tenant_name: Args.string({
-            description: 'Ephemeral tenant name',
-            required: true,
-        }),
-    };
-    static description = 'List all static hosts for an ephemeral tenant from the Xano Metadata API';
-    static examples = [
-        `$ xano ephemeral static_host list e4f2-9ab1-xyz1 -w 40
-Available static hosts:
-  - my-static-host (ID: 1)
-  - another-host (ID: 2)
-`,
-        `$ xano ephemeral static_host list e4f2-9ab1-xyz1 --profile production
-Available static hosts:
-  - my-static-host (ID: 1)
-  - another-host (ID: 2)
-`,
-        `$ xano ephemeral static_host list e4f2-9ab1-xyz1 -w 40 --output json
-{
-  "count": 1,
-  "page": 1,
-  "total": 3,
-  "items": [
-    {
-      "id": 1,
-      "name": "my-static-host"
-    }
-  ]
-}
-`,
-        `$ xano ephemeral static_host list e4f2-9ab1-xyz1 -p staging -o json --page 2
-[
-  {
-    "id": 3,
-    "name": "static-host-3"
-  }
-]
-`,
-    ];
-    static flags = {
-        ...BaseCommand.baseFlags,
-        output: Flags.string({
-            char: 'o',
-            default: 'summary',
-            description: 'Output format',
-            options: ['summary', 'json'],
-            required: false,
-        }),
-        ...pagingFlags('page-only-envelope', { fixedPerPage: 100 }),
-        workspace: Flags.string({
-            char: 'w',
-            description: 'Workspace ID (optional if set in profile)',
-            required: false,
-        }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(EphemeralStaticHostList);
-        const { profile, profileName } = this.resolveProfile(flags);
-        const tenantName = args.tenant_name;
-        // Determine workspace_id from flag or profile
-        let workspaceId;
-        if (flags.workspace) {
-            workspaceId = flags.workspace;
-        }
-        else if (profile.workspace) {
-            workspaceId = profile.workspace;
-        }
-        else {
-            this.error(`Workspace ID is required. Either:\n` +
-                `  1. Provide it as a flag: xano ephemeral static_host list <tenant_name> -w <workspace_id>\n` +
-                `  2. Set it in your profile using: xano profile:edit ${profileName} -w <workspace_id>`);
-        }
-        // Build query parameters
-        const queryParams = new URLSearchParams(buildPagingParams(flags, 'page-only-envelope'));
-        // Construct the API URL
-        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}/static_host?${queryParams.toString()}`;
-        // Fetch static hosts from the API
-        try {
-            const response = await this.verboseFetch(apiUrl, {
-                headers: {
-                    'accept': 'application/json',
-                    'Authorization': `Bearer ${profile.access_token}`,
-                },
-                method: 'GET',
-            }, flags.verbose, profile.access_token);
-            if (!response.ok) {
-                const errorText = await response.text();
-                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
-            }
-            const list = normalizeListResponse(await response.json(), ['static_hosts']);
-            const staticHosts = list.items;
-            // Output results
-            if (flags.output === 'json') {
-                this.log(JSON.stringify(buildPagingJson(list, { page: flags.page, tier: 'page-only-envelope' }), null, 2));
-            }
-            else {
-                // summary format
-                if (staticHosts.length === 0) {
-                    this.log('No static hosts found');
-                }
-                else {
-                    this.log('Available static hosts:');
-                    for (const host of staticHosts) {
-                        if (host.id === undefined) {
-                            this.log(`  - ${host.name}`);
-                        }
-                        else {
-                            const domainInfo = host.domain ? ` - ${host.domain}` : '';
-                            this.log(`  - ${host.name} (ID: ${host.id})${domainInfo}`);
-                        }
-                    }
-                }
-                const footer = formatPagingFooter(list, { noun: 'static host', page: flags.page, tier: 'page-only-envelope' });
-                if (footer)
-                    this.log(footer);
-            }
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                this.error(`Failed to fetch static hosts: ${error.message}`);
-            }
-            else {
-                this.error(`Failed to fetch static hosts: ${String(error)}`);
-            }
-        }
-    }
-}

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

@@ -1,53 +0,0 @@
-/**
- * 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

@@ -1,83 +0,0 @@
-/**
- * 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);
-    }
-}