@xano/cli 1.2.0 → 1.3.0

package/dist/base-command.js

@@ -2,7 +2,7 @@ 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';
-import * as path from 'node:path';
+import path from 'node:path';
 import { Agent } from 'undici';
 import { checkForUpdate } from './update-check.js';
 import { applyLocalOverrides, findLocalProfilePath, formatLocalProfileBanner, parseLocalProfile, resolveProfileSelection, } from './utils/local-config.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;
@@ -103,76 +136,6 @@ export default class BaseCommand extends Command {
     // Null when none was found or when an explicit -p/XANO_PROFILE overrides it.
     localProfile = null;
     updateNotice = null;
-    async init() {
-        await super.init();
-        this.localProfile = this.loadLocalProfile();
-        this.applyInsecureFromProfile();
-        this.maybePrintLocalProfileBanner();
-        const forceUpdateCheck = process.env.XANO_FORCE_UPDATE_CHECK === '1';
-        this.updateNotice = checkForUpdate(this.config.version, forceUpdateCheck);
-    }
-    /**
-     * Find and parse the nearest project-local profile.yaml, unless an explicit
-     * -p/XANO_PROFILE was given (in which case the local file is ignored).
-     */
-    loadLocalProfile() {
-        if (argvHasProfileFlag(process.argv, process.env)) {
-            return null;
-        }
-        // Walks up to the filesystem root (git-style). parseLocalProfile returns
-        // null for a profile.yaml with no recognized keys, so an unrelated file
-        // belonging to another tool is ignored rather than hijacked.
-        const filePath = findLocalProfilePath(process.cwd());
-        if (!filePath) {
-            return null;
-        }
-        let config;
-        try {
-            config = parseLocalProfile(fs.readFileSync(filePath, 'utf8'));
-        }
-        catch (error) {
-            this.error(`${filePath}: ${error.message}`);
-        }
-        if (!config) {
-            this.warn(`Ignoring ${filePath}: no recognized profile keys found.`);
-            return null;
-        }
-        return { config, path: filePath };
-    }
-    /** Print the one-line target banner when a local profile.yaml is in effect. */
-    maybePrintLocalProfileBanner() {
-        if (!this.localProfile || this.isJsonOutput()) {
-            return;
-        }
-        // Credential-management commands (the `profile` topic) operate on the
-        // credentials store directly and intentionally ignore the project-local
-        // pin, so the banner would be misleading for them.
-        if (this.id?.startsWith('profile')) {
-            return;
-        }
-        const { config, path: filePath } = this.localProfile;
-        const profileName = config.profile ?? this.getDefaultProfile();
-        const relativePath = path.relative(process.cwd(), filePath) || path.basename(filePath);
-        this.log(formatLocalProfileBanner(profileName, config.workspace, relativePath));
-    }
-    async finally(_) {
-        if (this.updateNotice && !this.isJsonOutput()) {
-            this.log(this.updateNotice);
-        }
-        await super.finally(_);
-    }
-    isJsonOutput() {
-        const args = process.argv;
-        for (let i = 0; i < args.length; i++) {
-            if (args[i] === '--output' && args[i + 1] === 'json')
-                return true;
-            if (args[i] === '-o' && args[i + 1] === 'json')
-                return true;
-            if (args[i] === '--output=json' || args[i] === '-o=json')
-                return true;
-        }
-        return false;
-    }
     /**
      * Apply insecure TLS mode if the active profile has insecure: true.
      * Sets NODE_TLS_REJECT_UNAUTHORIZED=0 so all fetch() calls skip cert verification.
@@ -193,22 +156,11 @@ export default class BaseCommand extends Command {
             // Don't fail the command if we can't read the profile for insecure check
         }
     }
-    // Helper method to get the default profile from credentials file
-    getDefaultProfile() {
-        try {
-            const credentials = this.loadCredentialsFile();
-            if (credentials?.default) {
-                return credentials.default;
-            }
-            return 'default';
-        }
-        catch {
-            return 'default';
+    async finally(_) {
+        if (this.updateNotice && !this.isJsonOutput()) {
+            this.log(this.updateNotice);
         }
-    }
-    // Helper method to get the profile flag value
-    getProfile() {
-        return this.flags?.profile;
+        await super.finally(_);
     }
     /**
      * Get the resolved credentials file path, respecting --config flag and XANO_CONFIG env var.
@@ -225,17 +177,18 @@ export default class BaseCommand extends Command {
         }
         return resolveCredentialsPath();
     }
-    loadCredentialsFile() {
-        const credentialsPath = this.getCredentialsPath();
-        if (!fs.existsSync(credentialsPath)) {
-            return null;
+    // Helper method to get the default profile from credentials file
+    getDefaultProfile() {
+        try {
+            const credentials = this.loadCredentialsFile();
+            if (credentials?.default) {
+                return credentials.default;
+            }
+            return 'default';
         }
-        const fileContent = fs.readFileSync(credentialsPath, 'utf8');
-        const parsed = yaml.load(fileContent);
-        if (parsed && typeof parsed === 'object' && 'profiles' in parsed) {
-            return parsed;
+        catch {
+            return 'default';
         }
-        return null;
     }
     /**
      * Get or create the singleton sandbox environment for the authenticated user.
@@ -256,6 +209,92 @@ export default class BaseCommand extends Command {
         }
         return (await response.json());
     }
+    // Helper method to get the profile flag value
+    getProfile() {
+        return this.flags?.profile;
+    }
+    async init() {
+        await super.init();
+        this.localProfile = this.loadLocalProfile();
+        this.applyInsecureFromProfile();
+        this.maybePrintLocalProfileBanner();
+        const forceUpdateCheck = process.env.XANO_FORCE_UPDATE_CHECK === '1';
+        this.updateNotice = checkForUpdate(this.config.version, forceUpdateCheck);
+    }
+    loadCredentialsFile() {
+        const credentialsPath = this.getCredentialsPath();
+        if (!fs.existsSync(credentialsPath)) {
+            return null;
+        }
+        const fileContent = fs.readFileSync(credentialsPath, 'utf8');
+        const parsed = yaml.load(fileContent);
+        if (parsed && typeof parsed === 'object' && 'profiles' in parsed) {
+            return parsed;
+        }
+        return null;
+    }
+    /**
+     * 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, tenantName, verbose, workspaceId } = opts;
+        // When a tenant is scoped, target the tenant's static hosting; otherwise the
+        // workspace-level static host (default, unchanged behavior).
+        const scope = tenantName ? `/tenant/${tenantName}` : '';
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}${scope}/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.
+        }
+    }
+    /**
+     * Parse an API error response and return a clean error message.
+     * Extracts the message from JSON responses and adds context for common errors.
+     */
+    async parseApiError(response, fallbackPrefix) {
+        const errorText = await response.text();
+        let message = `${fallbackPrefix} (${response.status})`;
+        try {
+            const errorJson = JSON.parse(errorText);
+            if (errorJson.message) {
+                message = errorJson.message;
+            }
+        }
+        catch {
+            if (errorText) {
+                message += `\n${errorText}`;
+            }
+        }
+        // Provide guidance when sandbox access is denied (free plan restriction)
+        if (response.status === 500 && message === 'Access Denied.') {
+            message = 'Sandbox is not available on the Free plan. Upgrade your plan to use sandbox features.';
+        }
+        return message;
+    }
     /**
      * Resolve the profile from flags and any project-local profile.yaml,
      * validating instance_origin and access_token exist.
@@ -289,30 +328,6 @@ export default class BaseCommand extends Command {
         }
         return { profile, profileName };
     }
-    /**
-     * Parse an API error response and return a clean error message.
-     * Extracts the message from JSON responses and adds context for common errors.
-     */
-    async parseApiError(response, fallbackPrefix) {
-        const errorText = await response.text();
-        let message = `${fallbackPrefix} (${response.status})`;
-        try {
-            const errorJson = JSON.parse(errorText);
-            if (errorJson.message) {
-                message = errorJson.message;
-            }
-        }
-        catch {
-            if (errorText) {
-                message += `\n${errorText}`;
-            }
-        }
-        // Provide guidance when sandbox access is denied (free plan restriction)
-        if (response.status === 500 && message === 'Access Denied.') {
-            message = 'Sandbox is not available on the Free plan. Upgrade your plan to use sandbox features.';
-        }
-        return message;
-    }
     /**
      * Make an HTTP request with optional verbose logging.
      * Use this for all Metadata API calls to support the --verbose flag.
@@ -324,15 +339,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 +369,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)`);
@@ -358,47 +397,15 @@ 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 { buildId, profile, quiet, staticHost, tenantName, 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}`;
+        // When a tenant is scoped, target the tenant's static hosting; otherwise the
+        // workspace-level static host (default, unchanged behavior).
+        const scope = tenantName ? `/tenant/${tenantName}` : '';
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}${scope}/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;
@@ -461,6 +468,62 @@ export default class BaseCommand extends Command {
         conclude(`stopped waiting after ${Math.round(timeoutMs / 1000)}s (last status: ${stage || 'unknown'})`);
         return stage;
     }
+    isJsonOutput() {
+        const args = process.argv;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--output' && args[i + 1] === 'json')
+                return true;
+            if (args[i] === '-o' && args[i + 1] === 'json')
+                return true;
+            if (args[i] === '--output=json' || args[i] === '-o=json')
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Find and parse the nearest project-local profile.yaml, unless an explicit
+     * -p/XANO_PROFILE was given (in which case the local file is ignored).
+     */
+    loadLocalProfile() {
+        if (argvHasProfileFlag(process.argv, process.env)) {
+            return null;
+        }
+        // Walks up to the filesystem root (git-style). parseLocalProfile returns
+        // null for a profile.yaml with no recognized keys, so an unrelated file
+        // belonging to another tool is ignored rather than hijacked.
+        const filePath = findLocalProfilePath(process.cwd());
+        if (!filePath) {
+            return null;
+        }
+        let config;
+        try {
+            config = parseLocalProfile(fs.readFileSync(filePath, 'utf8'));
+        }
+        catch (error) {
+            this.error(`${filePath}: ${error.message}`);
+        }
+        if (!config) {
+            this.warn(`Ignoring ${filePath}: no recognized profile keys found.`);
+            return null;
+        }
+        return { config, path: filePath };
+    }
+    /** Print the one-line target banner when a local profile.yaml is in effect. */
+    maybePrintLocalProfileBanner() {
+        if (!this.localProfile || this.isJsonOutput()) {
+            return;
+        }
+        // Credential-management commands (the `profile` topic) operate on the
+        // credentials store directly and intentionally ignore the project-local
+        // pin, so the banner would be misleading for them.
+        if (this.id?.startsWith('profile')) {
+            return;
+        }
+        const { config, path: filePath } = this.localProfile;
+        const profileName = config.profile ?? this.getDefaultProfile();
+        const relativePath = path.relative(process.cwd(), filePath) || path.basename(filePath);
+        this.log(formatLocalProfileBanner(profileName, config.workspace, relativePath));
+    }
 }
 /** Human-friendly label for a build status stage. */
 function stageLabel(status) {

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

@@ -48,10 +48,10 @@ export default class Auth extends Command {
     run(): Promise<AuthResult>;
     protected toErrorJson(err: unknown): unknown;
     private acquireToken;
-    private getHeaders;
     private fetchBranches;
     private fetchInstances;
     private fetchWorkspaces;
+    private getHeaders;
     private promptForToken;
     private promptProfileName;
     private readTokenFromStdin;

package/dist/commands/auth/index.js

@@ -212,13 +212,6 @@ To authenticate, open the following URL in any browser:
         }
         return noBrowser ? this.promptForToken(origin) : this.startAuthServer(origin);
     }
-    getHeaders(accessToken) {
-        return {
-            'User-Agent': buildUserAgent(this.config.version),
-            accept: 'application/json',
-            ...(accessToken && { Authorization: `Bearer ${accessToken}` }),
-        };
-    }
     async fetchBranches(accessToken, origin, workspaceId) {
         try {
             const response = await fetch(`${origin}/api:meta/workspace/${workspaceId}/branch`, {
@@ -288,6 +281,13 @@ To authenticate, open the following URL in any browser:
             return [];
         }
     }
+    getHeaders(accessToken) {
+        return {
+            accept: 'application/json',
+            'User-Agent': buildUserAgent(this.config.version),
+            ...(accessToken && { Authorization: `Bearer ${accessToken}` }),
+        };
+    }
     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

package/dist/commands/branch/create/index.d.ts

@@ -1,9 +1,9 @@
 import BaseCommand from '../../../base-command.js';
 export default class BranchCreate extends BaseCommand {
-    static description: string;
     static args: {
         label: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
     static examples: string[];
     static flags: {
         color: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/branch/create/index.js

@@ -1,13 +1,13 @@
 import { Args, Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
 export default class BranchCreate extends BaseCommand {
-    static description = 'Create a new branch by cloning from an existing branch';
     static args = {
         label: Args.string({
             description: 'Label for the new branch',
             required: true,
         }),
     };
+    static description = 'Create a new branch by cloning from an existing branch';
     static examples = [
         `$ xano branch create dev
 Created branch: dev

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

@@ -0,0 +1,18 @@
+import BaseCommand from '../../../base-command.js';
+export default class EphemeralCreate extends BaseCommand {
+    static args: {
+        display: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'expires-hours': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,103 @@
+import { Args, Flags } from '@oclif/core';
+import BaseCommand from '../../../base-command.js';
+export default class EphemeralCreate extends BaseCommand {
+    static args = {
+        display: Args.string({
+            description: 'Display name for the ephemeral tenant',
+            required: true,
+        }),
+    };
+    static description = 'Create a new ephemeral (short-lived, auto-expiring) tenant in a workspace';
+    static examples = [
+        `$ xano ephemeral create "PR preview"
+Created ephemeral tenant: PR preview (e4f2-9ab1-...) - ID: 42
+  Expires: in 1 hour
+`,
+        `$ xano ephemeral create "Demo" --expires-hours 24 -w 114`,
+        `$ xano ephemeral create "Load test" --description "overnight soak" --expires-hours 24 -o json`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        description: Flags.string({
+            char: 'd',
+            description: 'Ephemeral tenant description',
+            required: false,
+        }),
+        'expires-hours': Flags.integer({
+            default: 1,
+            description: 'Hours until the tenant auto-expires (1-24)',
+            max: 24,
+            min: 1,
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EphemeralCreate);
+        const { profile } = this.resolveProfile(flags);
+        // Ephemeral tenants REQUIRE a workspace (unlike sandbox, which is workspace-agnostic).
+        const workspaceId = flags.workspace || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Ephemeral tenants require a workspace — use --workspace or set one in your profile.');
+        }
+        const body = {
+            display: args.display,
+            expires_hours: flags['expires-hours'],
+            tag: [],
+        };
+        if (flags.description)
+            body.description = flags.description;
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/ephemeral`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify(body),
+                headers: {
+                    accept: 'application/json',
+                    Authorization: `Bearer ${profile.access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            }, 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 tenant = (await response.json());
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(tenant, null, 2));
+            }
+            else {
+                this.log(`Created ephemeral tenant: ${tenant.display || tenant.name} (${tenant.name}) - ID: ${tenant.id}`);
+                if (tenant.state) {
+                    this.log(`  State: ${tenant.state}`);
+                }
+                if (tenant.ephemeral_expires_at) {
+                    // The API serializes the timestamp field as a date string
+                    // ("2026-07-24 19:49:15+0000"); tolerate a raw unix-epoch number too.
+                    const raw = tenant.ephemeral_expires_at;
+                    const expiresMs = typeof raw === 'number' ? raw * 1000 : Date.parse(String(raw).replace(' ', 'T'));
+                    this.log(`  Expires: ${Number.isNaN(expiresMs) ? String(raw) : new Date(expiresMs).toISOString()}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to create ephemeral tenant: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to create ephemeral tenant: ${String(error)}`);
+            }
+        }
+    }
+}