@xano/cli 1.0.3 → 1.0.4-beta.2

package/README.md

@@ -46,8 +46,42 @@ These warnings are layer 1 of broader push-safety work; ephemeral sandbox enviro
 xano auth
 xano auth --origin https://custom.xano.com
 xano auth --insecure                         # Skip TLS verification (self-signed certs)
+xano auth --no-browser                       # Headless login (no local callback server)
+
+# Pre-select instance/workspace/branch and profile name (skips the pickers)
+xano auth -i my-instance -w 5 -b dev -p staging
+xano auth --instance my-instance --workspace "My Workspace" --branch dev --profile staging
+
+# Pass "" to take a picker's default: skip workspace, use live branch, default profile name
+xano auth -i my-instance -w 5 -b "" -p ""
 ```
 
+The default flow starts a temporary callback server on `127.0.0.1` and waits
+for the browser to redirect back to it. On remote/SSH sessions, Docker
+containers, or locked-down networks where the browser can't reach the CLI's
+loopback address, use `--no-browser`: the CLI prints a login URL, you open it
+in any browser, and paste back the code it displays. No local server required.
+
+Each picker can be pre-answered with a flag: `-i/--instance` (instance name, or numeric instance ID),
+`-w/--workspace` (workspace ID or name), `-b/--branch` (branch label), and
+`-p/--profile` (profile name to save). An empty value (`""`) takes the
+picker's default answer: `-w ""` skips workspace selection, `-b ""` skips and
+uses the live branch, and `-p ""` uses the default profile name. With all four
+set alongside `--no-browser`, the only input is pasting the code from the
+browser — useful for scripted or remote setups.
+
+When stdin is piped (not a TTY), `--no-browser` reads the code directly from
+stdin instead of prompting, so scripts and AI agents can complete the flow
+without an interactive terminal:
+
+```bash
+echo "$CODE" | xano auth --no-browser -i my-instance -w 5 -b dev -p staging
+```
+
+If you can't run `xano auth` at all, you can always create a profile manually
+with a Metadata API token from the Xano dashboard — see
+[Profiles](#profiles) below.
+
 ### Profiles
 
 Profiles store your Xano credentials and default workspace settings.
@@ -522,14 +556,46 @@ xano sandbox reset --force
 # List static hosts
 xano static_host list
 
-# Create a build
-xano static_host build create default -f ./build.zip -n "v1.0.0"
+# Create / get / edit a static host
+xano static_host create marketing --description "Marketing site"
+xano static_host get marketing
+xano static_host edit marketing --name marketing-v2 --description "Updated"
 
 # List builds
 xano static_host build list default
 
 # Get build details
-xano static_host build get default 52
+xano static_host build get default --build_id 52
+
+# Pull a build to disk. Defaults to the original uploaded source
+# (including package.json). Use --source built for the compiled/served output.
+xano static_host build pull default --build_id 52    # By build ID (original source)
+xano static_host build pull default --build_id 52 --source built   # Compiled output
+xano static_host build pull default --latest         # Latest build
+xano static_host build pull default --env dev        # Build currently deployed to dev
+xano static_host build pull default --env prod -d ./prod-release
+
+# Push a build (name optional — auto-generated from the timestamp if omitted).
+# Accepts a directory (-d) or a zip file (-f). Defaults to the current directory.
+# For package.json builds, the CLI waits for the build to finish (--no-wait to skip).
+xano static_host build push default -d ./dist -n "v1.0.0"
+xano static_host build push default                          # current dir, auto-name
+xano static_host build push default -f ./build.zip -n "v1.0.0"  # from zip file
+xano static_host build push default -n "release" --description "Production build"
+
+# Delete a build (prompts for confirmation; --force to skip)
+xano static_host build delete default --build_id 52
+xano static_host build delete default --build_id 52 --force
+
+# Deploy a build to an environment
+xano static_host deploy default --build_id 52 --env dev
+xano static_host deploy default --build_id 52 --env prod
+
+# Migrate a host to instance-managed (v2) hosting
+xano static_host migrate newsite                 # one host (both envs)
+xano static_host migrate newsite --env dev        # one env
+xano static_host migrate --all                    # every v1 host in the workspace
+xano static_host migrate --all --dry-run          # preview without changing anything
 ```
 
 ## Global Options

package/dist/base-command.d.ts

@@ -103,4 +103,31 @@ export default abstract class BaseCommand extends Command {
      * Use this for all Metadata API calls to support the --verbose flag.
      */
     protected verboseFetch(url: string, options: RequestInit, verbose: boolean, authToken?: string): Promise<Response>;
+    /**
+     * Poll a static-host build until it reaches a terminal status (ok | error),
+     * showing a live, ticking spinner with the current stage and elapsed time —
+     * mirroring the UI's build progress for async (package.json) builds, which
+     * keep running after the upload returns.
+     *
+     * On a TTY it renders an animated spinner via ux.action; when quiet (JSON
+     * output) or non-interactive it falls back to plain one-line status updates.
+     *
+     * Returns the final status. Resolves to the last-seen status on timeout.
+     */
+    protected logStaticHostUrls(opts: {
+        profile: ProfileConfig;
+        staticHost: string;
+        verbose: boolean;
+        workspaceId: string;
+    }): Promise<void>;
+    protected waitForBuild(opts: {
+        buildId: number | string;
+        intervalMs?: number;
+        profile: ProfileConfig;
+        quiet?: boolean;
+        staticHost: string;
+        timeoutMs?: number;
+        verbose: boolean;
+        workspaceId: string;
+    }): Promise<string>;
 }

package/dist/base-command.js

@@ -1,4 +1,4 @@
-import { Command, Flags } from '@oclif/core';
+import { Command, Flags, ux } from '@oclif/core';
 import * as yaml from 'js-yaml';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
@@ -358,4 +358,127 @@ export default class BaseCommand extends Command {
         }
         return response;
     }
+    /**
+     * Poll a static-host build until it reaches a terminal status (ok | error),
+     * showing a live, ticking spinner with the current stage and elapsed time —
+     * mirroring the UI's build progress for async (package.json) builds, which
+     * keep running after the upload returns.
+     *
+     * On a TTY it renders an animated spinner via ux.action; when quiet (JSON
+     * output) or non-interactive it falls back to plain one-line status updates.
+     *
+     * Returns the final status. Resolves to the last-seen status on timeout.
+     */
+    async logStaticHostUrls(opts) {
+        const { profile, staticHost, verbose, workspaceId } = opts;
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${staticHost}`;
+        try {
+            const response = await this.verboseFetch(url, {
+                headers: { accept: 'application/json', Authorization: `Bearer ${profile.access_token}` },
+                method: 'GET',
+            }, verbose, profile.access_token);
+            if (!response.ok)
+                return;
+            const host = (await response.json());
+            if (host.dev?.default_url)
+                this.log(`Dev URL: ${host.dev.default_url}`);
+            if (host.dev?.custom_url)
+                this.log(`Dev Custom URL: ${host.dev.custom_url}`);
+            if (host.prod?.default_url)
+                this.log(`Prod URL: ${host.prod.default_url}`);
+            if (host.prod?.custom_url)
+                this.log(`Prod Custom URL: ${host.prod.custom_url}`);
+        }
+        catch {
+            // Non-fatal — the build succeeded, we just can't show the URL.
+        }
+    }
+    async waitForBuild(opts) {
+        const { buildId, profile, quiet, staticHost, verbose, workspaceId } = opts;
+        const intervalMs = opts.intervalMs ?? 2000;
+        const timeoutMs = opts.timeoutMs ?? 600_000; // 10 min
+        const terminal = new Set(['error', 'ok']);
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${staticHost}/build/${buildId}`;
+        // Spinner only on an interactive TTY and when not emitting JSON. Verbose mode
+        // also disables it (the spinner would interleave with request/response logs).
+        const animate = Boolean(process.stdout.isTTY) && !quiet && !verbose;
+        const start = Date.now();
+        const elapsed = () => Math.round((Date.now() - start) / 1000);
+        let stage = 'pending';
+        let ticker;
+        // Reflect the current stage: live spinner status on a TTY, else a plain line.
+        const render = () => {
+            if (animate) {
+                ux.action.status = `${stageLabel(stage)} (${elapsed()}s)`;
+            }
+            else if (!quiet && !terminal.has(stage)) {
+                this.log(`Build status: ${stage}`);
+            }
+        };
+        // Stop the spinner/ticker and emit a final line.
+        const conclude = (message) => {
+            if (ticker)
+                clearInterval(ticker);
+            if (animate) {
+                ux.action.stop(message);
+            }
+            else if (!quiet) {
+                this.log(message);
+            }
+        };
+        if (animate) {
+            ux.action.start('Building', stageLabel(stage));
+            // Re-render every 120ms so the elapsed counter ticks even between polls.
+            ticker = setInterval(render, 120);
+        }
+        else if (!quiet) {
+            this.log(`Build status: ${stage}`);
+        }
+        /* eslint-disable no-await-in-loop */
+        while (Date.now() - start < timeoutMs) {
+            const response = await this.verboseFetch(url, {
+                headers: { accept: 'application/json', Authorization: `Bearer ${profile.access_token}` },
+                method: 'GET',
+            }, verbose, profile.access_token);
+            if (response.ok) {
+                const build = (await response.json());
+                const status = build.status ?? 'pending';
+                if (status !== stage) {
+                    stage = status;
+                    render();
+                }
+                if (terminal.has(status)) {
+                    const took = `${elapsed()}s`;
+                    conclude(status === 'ok' ? `done in ${took}` : `failed after ${took}`);
+                    return status;
+                }
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, intervalMs);
+            });
+        }
+        /* eslint-enable no-await-in-loop */
+        conclude(`stopped waiting after ${Math.round(timeoutMs / 1000)}s (last status: ${stage || 'unknown'})`);
+        return stage;
+    }
+}
+/** Human-friendly label for a build status stage. */
+function stageLabel(status) {
+    switch (status) {
+        case 'building': {
+            return 'Installing & building (npm)';
+        }
+        case 'ok': {
+            return 'Finishing';
+        }
+        case 'pending': {
+            return 'Queued';
+        }
+        case 'publishing': {
+            return 'Publishing files';
+        }
+        default: {
+            return status;
+        }
+    }
 }

package/dist/commands/auth/index.d.ts

@@ -3,16 +3,26 @@ export default class Auth extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        branch: 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>;
         insecure: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        instance: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-browser': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         origin: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     private getHeaders;
     private fetchBranches;
     private fetchInstances;
     private fetchWorkspaces;
+    private promptForToken;
     private promptProfileName;
+    private readTokenFromStdin;
+    private resolveBranch;
+    private resolveInstance;
+    private resolveWorkspace;
     private saveProfile;
     private selectBranch;
     private selectInstance;

package/dist/commands/auth/index.js

@@ -1,4 +1,3 @@
-import { ExitPromptError } from '@inquirer/core';
 import { Command, Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import * as yaml from 'js-yaml';
@@ -20,8 +19,21 @@ Authenticated as John Doe (john@example.com)
 Profile 'default' created successfully!`,
         `$ xano auth --origin https://custom.xano.com
 Opening browser for Xano login at https://custom.xano.com...`,
+        `$ xano auth --no-browser
+To authenticate, open the following URL in any browser:
+  https://app.xano.com/login?dest=cli&display=code
+? Paste the code shown in your browser: ****`,
+        `$ xano auth --no-browser --instance my-instance --workspace 5 --branch dev --profile staging
+(non-interactive: only the pasted code is prompted for)`,
+        `$ echo "$CODE" | xano auth --no-browser --instance my-instance --workspace 5 --branch dev --profile staging
+(fully scripted: the code is read from piped stdin, no prompt at all)`,
     ];
     static flags = {
+        branch: Flags.string({
+            char: 'b',
+            description: 'Pre-select a branch by label (skips the branch picker); pass "" to skip and use the live branch',
+            required: false,
+        }),
         config: Flags.string({
             char: 'c',
             description: 'Path to credentials file (default: ~/.xano/credentials.yaml)',
@@ -33,11 +45,30 @@ Opening browser for Xano login at https://custom.xano.com...`,
             default: false,
             description: 'Skip TLS certificate verification (for self-signed certificates)',
         }),
+        instance: Flags.string({
+            char: 'i',
+            description: 'Pre-select an instance by name or numeric ID (skips the instance picker)',
+            required: false,
+        }),
+        'no-browser': Flags.boolean({
+            default: false,
+            description: 'Headless login: print a URL and paste back the code shown in the browser, instead of starting a local callback server (use on remote/SSH/Docker hosts where 127.0.0.1 is not reachable from the browser)',
+        }),
         origin: Flags.string({
             char: 'o',
             default: 'https://app.xano.com',
             description: 'Xano account origin URL',
         }),
+        profile: Flags.string({
+            char: 'p',
+            description: 'Profile name to save (skips the profile name prompt); pass "" to use the default name',
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Pre-select a workspace by ID or name (skips the workspace picker); pass "" to skip workspace',
+            required: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(Auth);
@@ -48,7 +79,9 @@ Opening browser for Xano login at https://custom.xano.com...`,
         try {
             // Step 1: Get token via browser auth
             this.log('Starting authentication flow...');
-            const token = await this.startAuthServer(flags.origin);
+            const token = flags['no-browser']
+                ? await this.promptForToken(flags.origin)
+                : await this.startAuthServer(flags.origin);
             // Step 2: Validate token and get user info
             this.log('');
             this.log('Validating authentication...');
@@ -60,6 +93,9 @@ Opening browser for Xano login at https://custom.xano.com...`,
             const isSelfHosted = !/^https:\/\/app\.(.*\.)?xano\.com$/.test(flags.origin);
             let instance;
             if (isSelfHosted) {
+                if (flags.instance) {
+                    this.warn('Ignoring --instance: the origin itself is the instance for self-hosted Xano.');
+                }
                 instance = {
                     display: flags.origin,
                     id: 'self-hosted',
@@ -74,7 +110,7 @@ Opening browser for Xano login at https://custom.xano.com...`,
                 if (instances.length === 0) {
                     this.error('No instances found. Please check your account.');
                 }
-                instance = await this.selectInstance(instances);
+                instance = await this.resolveInstance(instances, flags.instance);
             }
             // Step 4: Workspace selection
             let workspace;
@@ -83,20 +119,25 @@ Opening browser for Xano login at https://custom.xano.com...`,
             this.log('Fetching available workspaces...');
             const workspaces = await this.fetchWorkspaces(token, instance.origin);
             if (workspaces.length > 0) {
-                workspace = await this.selectWorkspace(workspaces);
+                workspace = await this.resolveWorkspace(workspaces, flags.workspace);
                 if (workspace) {
                     // Step 5: Branch selection
                     this.log('');
                     this.log('Fetching available branches...');
                     const branches = await this.fetchBranches(token, instance.origin, workspace.id);
-                    if (branches.length > 1) {
-                        branch = await this.selectBranch(branches);
-                    }
+                    branch = await this.resolveBranch(branches, flags.branch);
                 }
             }
+            else if (flags.workspace) {
+                this.error(`Workspace '${flags.workspace}' not found: no workspaces are available on this instance.`);
+            }
+            if (flags.branch && !workspace) {
+                this.warn('Ignoring --branch: no workspace selected.');
+            }
             // Step 6: Profile name
             this.log('');
-            const profileName = await this.promptProfileName();
+            // An empty --profile value means "use the default name" (same as accepting the prompt's default)
+            const profileName = flags.profile === undefined ? await this.promptProfileName() : flags.profile.trim() || 'default';
             // Step 7: Save profile
             await this.saveProfile({
                 access_token: token,
@@ -113,7 +154,10 @@ Opening browser for Xano login at https://custom.xano.com...`,
             process.exit(0);
         }
         catch (error) {
-            if (error instanceof ExitPromptError) {
+            // Ctrl+C at an inquirer prompt throws ExitPromptError. Match on the name
+            // rather than `instanceof`: inquirer bundles its own copy of
+            // @inquirer/core, so the thrown class won't match an imported one.
+            if (error?.name === 'ExitPromptError') {
                 this.log('Authentication cancelled.');
                 return;
             }
@@ -167,7 +211,7 @@ Opening browser for Xano login at https://custom.xano.com...`,
         if (Array.isArray(data)) {
             return data.map((inst) => ({
                 display: inst.display,
-                id: inst.id || inst.name,
+                id: String(inst.id ?? inst.name),
                 name: inst.name,
                 origin: new URL(inst.meta_api).origin,
             }));
@@ -196,6 +240,45 @@ Opening browser for Xano login at https://custom.xano.com...`,
             return [];
         }
     }
+    async promptForToken(origin) {
+        // Headless flow: no local callback server. The login page, when opened
+        // without a `callback` param, renders the access token on screen for the
+        // user to copy. We point the browser there (best-effort) and prompt for
+        // the pasted code.
+        const authUrl = `${origin}/login?dest=cli&display=code`;
+        this.log('To authenticate, open the following URL in any browser:');
+        this.log('');
+        this.log(`  ${authUrl}`);
+        this.log('');
+        // Piped (non-TTY) stdin: read the code directly instead of prompting, so
+        // scripts and agents can do `echo $CODE | xano auth --no-browser ...`.
+        // The masked inquirer prompt below requires an interactive terminal.
+        if (!process.stdin.isTTY) {
+            const piped = await this.readTokenFromStdin();
+            if (!piped) {
+                this.error('No code received on stdin. Pipe the code shown in the browser, e.g. `echo "$CODE" | xano auth --no-browser ...`');
+            }
+            this.log('Read code from stdin.');
+            return piped;
+        }
+        try {
+            await open(authUrl);
+        }
+        catch {
+            // Best-effort only; the URL is already printed above for manual use.
+        }
+        const { token } = await inquirer.prompt([
+            {
+                message: 'Paste the code shown in your browser',
+                name: 'token',
+                type: 'password',
+                validate(input) {
+                    return input.trim() === '' ? 'A code is required' : true;
+                },
+            },
+        ]);
+        return token.trim();
+    }
     async promptProfileName() {
         const { profileName } = await inquirer.prompt([
             {
@@ -214,6 +297,63 @@ Opening browser for Xano login at https://custom.xano.com...`,
         ]);
         return profileName.trim() || 'default';
     }
+    readTokenFromStdin() {
+        return new Promise((resolve) => {
+            let data = '';
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on('end', () => resolve(data.trim()));
+            process.stdin.on('error', () => resolve(data.trim()));
+        });
+    }
+    async resolveBranch(branches, flagValue) {
+        if (flagValue !== undefined) {
+            // An empty value means "skip and use live branch" (same as the picker's skip option)
+            if (flagValue.trim() === '') {
+                this.log('Using live branch');
+                return undefined;
+            }
+            const match = branches.find((br) => br.label === flagValue || br.id === flagValue);
+            if (!match) {
+                this.error(`Branch '${flagValue}' not found. Available branches: ${branches.map((br) => br.label).join(', ')}`);
+            }
+            this.log(`Using branch: ${match.label}`);
+            return match.id;
+        }
+        return branches.length > 1 ? this.selectBranch(branches) : undefined;
+    }
+    async resolveInstance(instances, flagValue) {
+        if (flagValue) {
+            // Numeric values match by instance ID, anything else matches by name
+            const match = /^\d+$/.test(flagValue)
+                ? instances.find((inst) => inst.id === flagValue)
+                : instances.find((inst) => inst.name === flagValue);
+            if (!match) {
+                this.error(`Instance '${flagValue}' not found. Available instances: ${instances.map((inst) => `${inst.name} (${inst.id})`).join(', ')}`);
+            }
+            this.log(`Using instance: ${match.name} (${match.display})`);
+            return match;
+        }
+        return this.selectInstance(instances);
+    }
+    async resolveWorkspace(workspaces, flagValue) {
+        if (flagValue !== undefined) {
+            // An empty value means "skip workspace" (same as the picker's skip option)
+            if (flagValue.trim() === '') {
+                this.log('Skipping workspace selection');
+                return undefined;
+            }
+            const match = workspaces.find((ws) => String(ws.id) === flagValue || ws.name === flagValue);
+            if (!match) {
+                this.error(`Workspace '${flagValue}' not found. Available workspaces: ${workspaces.map((ws) => `${ws.name} (${ws.id})`).join(', ')}`);
+            }
+            this.log(`Using workspace: ${match.name} (${match.id})`);
+            return match;
+        }
+        return this.selectWorkspace(workspaces);
+    }
     async saveProfile(profile, configPath) {
         const credentialsPath = resolveCredentialsPath(configPath);
         const credDir = dirname(credentialsPath);

package/dist/commands/static_host/build/create/index.d.ts

@@ -1,5 +1,12 @@
 import BaseCommand from '../../../../base-command.js';
+/**
+ * Generate a default build name from a compact timestamp: `YYYYMMDD-HHmmss`
+ * (e.g. `20260531-143022`). Sortable, distinct down to the second, and uses
+ * local time so it lines up with when the user ran the command.
+ */
+export declare function generateBuildName(date?: Date): string;
 export default class StaticHostBuildCreate extends BaseCommand {
+    static hidden: boolean;
     static args: {
         static_host: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
@@ -8,7 +15,8 @@ export default class StaticHostBuildCreate extends BaseCommand {
     static flags: {
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         file: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         output: import("@oclif/core/interfaces").OptionFlag<string, 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>;

package/dist/commands/static_host/build/create/index.js

@@ -2,20 +2,42 @@ import { Args, Flags } from '@oclif/core';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import BaseCommand from '../../../../base-command.js';
+const pad2 = (n) => String(n).padStart(2, '0');
+/**
+ * Generate a default build name from a compact timestamp: `YYYYMMDD-HHmmss`
+ * (e.g. `20260531-143022`). Sortable, distinct down to the second, and uses
+ * local time so it lines up with when the user ran the command.
+ */
+export function generateBuildName(date = new Date()) {
+    const y = date.getFullYear();
+    const mo = pad2(date.getMonth() + 1);
+    const d = pad2(date.getDate());
+    const h = pad2(date.getHours());
+    const mi = pad2(date.getMinutes());
+    const s = pad2(date.getSeconds());
+    return `${y}${mo}${d}-${h}${mi}${s}`;
+}
 export default class StaticHostBuildCreate extends BaseCommand {
+    static hidden = true;
     static args = {
         static_host: Args.string({
             description: 'Static Host name',
             required: true,
         }),
     };
-    static description = 'Create a new build for a static host';
+    static description = '[Deprecated: use "static_host build push -f <file>" instead] Create a new build from a zip file';
     static examples = [
         `$ xano static_host:build:create default -f ./build.zip -n "v1.0.0"
 Build created successfully!
 ID: 123
 Name: v1.0.0
 Status: pending
+`,
+        `$ xano static_host:build:create default -f ./build.zip
+Build created successfully!
+ID: 123
+Name: 20260531-143022
+Status: pending
 `,
         `$ xano static_host:build:create default -w 40 -f ./dist.zip -n "production" -d "Production build"
 Build created successfully!
@@ -45,8 +67,13 @@ Description: Production build
         }),
         name: Flags.string({
             char: 'n',
-            description: 'Build name',
-            required: true,
+            description: 'Build name (auto-generated from the current timestamp if omitted)',
+            required: false,
+        }),
+        'no-wait': Flags.boolean({
+            default: false,
+            description: 'Return immediately after upload instead of waiting for the build to finish',
+            required: false,
         }),
         output: Flags.string({
             char: 'o',
@@ -62,6 +89,7 @@ Description: Production build
         }),
     };
     async run() {
+        this.warn('`static_host build create` is deprecated. Use `static_host build push -f <file>` instead.');
         const { args, flags } = await this.parse(StaticHostBuildCreate);
         const { profile, profileName } = this.resolveProfile(flags);
         // Determine workspace_id from flag or profile
@@ -102,7 +130,10 @@ Description: Production build
         const fileBuffer = fs.readFileSync(filePath);
         const blob = new Blob([fileBuffer], { type: 'application/zip' });
         formData.append('file', blob, path.basename(filePath));
-        formData.append('name', flags.name);
+        // Name is optional — fall back to a timestamped name so builds can be
+        // created without thinking up a label each time.
+        const buildName = flags.name ?? generateBuildName();
+        formData.append('name', buildName);
         if (flags.description) {
             formData.append('description', flags.description);
         }
@@ -141,6 +172,25 @@ Description: Production build
                     this.log(`Description: ${flags.description}`);
                 }
             }
+            // Async (package.json) builds keep running after upload. Unless --no-wait,
+            // poll until the build finishes so the CLI mirrors the UI's progress.
+            const inProgress = result.status !== undefined && !['error', 'ok'].includes(result.status);
+            if (inProgress && !flags['no-wait']) {
+                const finalStatus = await this.waitForBuild({
+                    buildId: result.id,
+                    profile,
+                    quiet: flags.output === 'json',
+                    staticHost: args.static_host,
+                    verbose: flags.verbose,
+                    workspaceId,
+                });
+                if (finalStatus === 'error') {
+                    this.error(`Build ${result.id} failed (status: error). Check the build log with: xano static_host build get ${args.static_host} --build_id ${result.id}`);
+                }
+            }
+            if (flags.output !== 'json') {
+                await this.logStaticHostUrls({ profile, staticHost: args.static_host, verbose: flags.verbose, workspaceId });
+            }
         }
         catch (error) {
             if (error instanceof Error) {