@xano/cli 1.0.4-beta.1 → 1.0.4-beta.10

package/README.md

@@ -62,7 +62,7 @@ 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),
+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
@@ -255,8 +255,35 @@ xano function edit <function_id> -f new.xs              # Update from file
 xano function edit <function_id> -f new.xs --edit       # Open in $EDITOR before updating
 cat function.xs | xano function edit <function_id> --stdin  # Update from stdin
 xano function edit <function_id> --no-publish           # Edit without publishing
+
+# Run (execute) a function by name
+xano function run <name>                                # Prompts for declared inputs (on a TTY)
+xano function run <name> --data email=jo@x.com --data age:=30 --data active:=true
+xano function run <name> --json @payload.json --data env=staging   # base payload + override
+echo '{"email":"jo@x.com"}' | xano function run <name> --stdin -o json | jq .result
+xano function run <name> --branch dev --logs            # run on a branch, show execution logs
 ```
 
+Input flexibility for `function run` (assembled into one JSON `input` object):
+
+| Form | Meaning |
+| --- | --- |
+| `--data key=value` | string field |
+| `--data key:=<json>` | raw JSON field (`age:=30`, `active:=true`, `tags:='["a","b"]'`) |
+| `--data key@file` | field value read from a file |
+| `--json '<inline>'` / `--json @file.json` / `--json -` | a base JSON object (stdin with `-`) |
+| `--stdin` | read the JSON object from stdin (same as `--json -`) |
+
+Merge order is JSON base first, then `--data` overrides. Missing required inputs are
+prompted for on an interactive terminal; in a non-TTY (CI) context the command fails
+listing them. Output defaults to the raw `result` (`-o json`); the exit code is non-zero
+when the function returns an error status.
+
+> **Permissions:** running a function requires **Function** (read) plus the **run/debug**
+> action on your workspace role. If your access token's role lacks run/debug, the call is
+> denied with an access error — grant run/debug to the role (or use a token whose role has
+> it). `function list`/`get`/`create`/`edit` only need the Function permission.
+
 ### Releases
 
 All release commands use **release names** (e.g., `v1.0`), not IDs.
@@ -326,6 +353,7 @@ xano unit_test list --branch dev --obj-type function
 
 # Run a single unit test
 xano unit_test run <unit_test_id>
+xano unit_test run <unit_test_id> --branch dev   # run the test from a specific branch
 
 # Run all unit tests
 xano unit_test run_all
@@ -577,11 +605,14 @@ 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.
+# When pushing a directory, files matched by its .gitignore are skipped by default
+# (the .git/ folder is always excluded); use --no-gitignore to push everything.
 # 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"
+xano static_host build push default -d ./static --no-gitignore  # push gitignored files too
 
 # Delete a build (prompts for confirmation; --force to skip)
 xano static_host build delete default --build_id 52

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

@@ -1,9 +1,42 @@
 import { Command } from '@oclif/core';
+export interface Instance {
+    display: string;
+    id: string;
+    name: string;
+    origin: string;
+}
+export interface AuthResult {
+    branch: null | string;
+    credentialsPath: string;
+    instance: {
+        id: string;
+        name: string;
+        origin: string;
+    };
+    profile: string;
+    user: {
+        email: string;
+        id: string;
+        name: string;
+    };
+    workspace: null | {
+        id: string;
+        name: string;
+    };
+}
+/**
+ * Match a user-supplied --instance value against the instance list:
+ * numeric values match by ID, URL/hostname values match by the instance
+ * origin's hostname, anything else matches by name. Exported for tests.
+ */
+export declare function matchInstance(instances: Instance[], query: string): Instance | undefined;
 export default class Auth extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        code: 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>;
@@ -12,7 +45,9 @@ export default class Auth extends Command {
         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>;
+    run(): Promise<AuthResult>;
+    protected toErrorJson(err: unknown): unknown;
+    private acquireToken;
     private getHeaders;
     private fetchBranches;
     private fetchInstances;
@@ -22,7 +57,9 @@ export default class Auth extends Command {
     private readTokenFromStdin;
     private resolveBranch;
     private resolveInstance;
+    private resolveProfileName;
     private resolveWorkspace;
+    private resolveWorkspaceAndBranch;
     private saveProfile;
     private selectBranch;
     private selectInstance;

package/dist/commands/auth/index.js

@@ -6,9 +6,37 @@ import * as http from 'node:http';
 import { dirname } from 'node:path';
 import open from 'open';
 import { buildUserAgent, resolveCredentialsPath } from '../../base-command.js';
+function originHostname(value) {
+    try {
+        return new URL(value.includes('://') ? value : `https://${value}`).hostname.toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Match a user-supplied --instance value against the instance list:
+ * numeric values match by ID, URL/hostname values match by the instance
+ * origin's hostname, anything else matches by name. Exported for tests.
+ */
+export function matchInstance(instances, query) {
+    const q = query.trim();
+    if (/^\d+$/.test(q)) {
+        return instances.find((inst) => inst.id === q);
+    }
+    if (q.includes('://') || q.includes('.')) {
+        const queryHost = originHostname(q);
+        const match = queryHost ? instances.find((inst) => originHostname(inst.origin) === queryHost) : undefined;
+        if (match) {
+            return match;
+        }
+    }
+    return instances.find((inst) => inst.name === q);
+}
 const AUTH_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 export default class Auth extends Command {
     static description = 'Authenticate with Xano via browser login';
+    static enableJsonFlag = true;
     static examples = [
         `$ xano auth
 Opening browser for Xano login...
@@ -23,10 +51,12 @@ Opening browser for Xano login at https://custom.xano.com...`,
 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)`,
+        `$ xano auth --code "$CODE" --instance https://my-instance.xano.io --workspace 5
+(fully non-interactive: no browser, no prompts; missing --branch/--profile fall back to defaults)`,
         `$ 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)`,
+        `$ xano auth --code "$CODE" --instance 42 --workspace 5 --json
+(machine-readable: prints the created profile as JSON)`,
     ];
     static flags = {
         branch: Flags.string({
@@ -34,6 +64,11 @@ To authenticate, open the following URL in any browser:
             description: 'Pre-select a branch by label (skips the branch picker); pass "" to skip and use the live branch',
             required: false,
         }),
+        code: Flags.string({
+            description: 'Login code copied from the browser (implies --no-browser and runs fully non-interactively). Get the code at <origin>/login?dest=cli&display=code',
+            env: 'XANO_AUTH_CODE',
+            required: false,
+        }),
         config: Flags.string({
             char: 'c',
             description: 'Path to credentials file (default: ~/.xano/credentials.yaml)',
@@ -47,7 +82,7 @@ To authenticate, open the following URL in any browser:
         }),
         instance: Flags.string({
             char: 'i',
-            description: 'Pre-select an instance by name (skips the instance picker)',
+            description: 'Pre-select an instance by name, numeric ID, or instance URL/hostname (skips the instance picker)',
             required: false,
         }),
         'no-browser': Flags.boolean({
@@ -76,12 +111,13 @@ To authenticate, open the following URL in any browser:
             process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
             this.warn('TLS certificate verification is disabled (insecure mode)');
         }
+        // A supplied code (flag or env), piped stdin, or --json output means no
+        // prompt can ever open: every unanswered picker falls back to its default.
+        const nonInteractive = flags.code !== undefined || (flags['no-browser'] && !process.stdin.isTTY) || this.jsonEnabled();
         try {
-            // Step 1: Get token via browser auth
+            // Step 1: Get token via supplied code or browser auth
             this.log('Starting authentication flow...');
-            const token = flags['no-browser']
-                ? await this.promptForToken(flags.origin)
-                : await this.startAuthServer(flags.origin);
+            const token = await this.acquireToken(flags.code, flags['no-browser'], flags.origin);
             // Step 2: Validate token and get user info
             this.log('');
             this.log('Validating authentication...');
@@ -110,36 +146,15 @@ To authenticate, open the following URL in any browser:
                 if (instances.length === 0) {
                     this.error('No instances found. Please check your account.');
                 }
-                instance = await this.resolveInstance(instances, flags.instance);
-            }
-            // Step 4: Workspace selection
-            let workspace;
-            let branch;
-            this.log('');
-            this.log('Fetching available workspaces...');
-            const workspaces = await this.fetchWorkspaces(token, instance.origin);
-            if (workspaces.length > 0) {
-                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);
-                    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.');
+                instance = await this.resolveInstance(instances, flags.instance, nonInteractive);
             }
+            // Steps 4 + 5: Workspace and branch selection
+            const { branch, workspace } = await this.resolveWorkspaceAndBranch(token, instance.origin, flags, nonInteractive);
             // Step 6: Profile name
             this.log('');
-            // 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';
+            const profileName = await this.resolveProfileName(flags.profile, nonInteractive);
             // Step 7: Save profile
-            await this.saveProfile({
+            const credentialsPath = await this.saveProfile({
                 access_token: token,
                 account_origin: flags.origin,
                 branch,
@@ -150,6 +165,17 @@ To authenticate, open the following URL in any browser:
             }, flags.config);
             this.log('');
             this.log(`Profile '${profileName}' created successfully!`);
+            const result = {
+                branch: branch ?? null,
+                credentialsPath,
+                instance: { id: instance.id, name: instance.name, origin: instance.origin },
+                profile: profileName,
+                user: { email: user.email, id: user.id, name: user.name },
+                workspace: workspace ? { id: workspace.id, name: workspace.name } : null,
+            };
+            if (this.jsonEnabled()) {
+                this.logJson(result);
+            }
             // Ensure clean exit (the open() call can keep the event loop alive)
             process.exit(0);
         }
@@ -159,11 +185,33 @@ To authenticate, open the following URL in any browser:
             // @inquirer/core, so the thrown class won't match an imported one.
             if (error?.name === 'ExitPromptError') {
                 this.log('Authentication cancelled.');
-                return;
+                this.exit(0);
             }
             throw error;
         }
     }
+    // oclif's default toErrorJson serializes Error objects to {} (message is a
+    // non-enumerable property), leaving --json consumers with no error detail.
+    toErrorJson(err) {
+        const error = err;
+        return {
+            error: {
+                ...(error.code ? { code: error.code } : {}),
+                message: error.message ?? String(err),
+                ...(error.suggestions?.length ? { suggestions: error.suggestions } : {}),
+            },
+        };
+    }
+    async acquireToken(code, noBrowser, origin) {
+        if (code !== undefined) {
+            const token = code.trim();
+            if (token === '') {
+                this.error(`No code provided. Copy it from ${origin}/login?dest=cli&display=code and pass it via --code or XANO_AUTH_CODE.`);
+            }
+            return token;
+        }
+        return noBrowser ? this.promptForToken(origin) : this.startAuthServer(origin);
+    }
     getHeaders(accessToken) {
         return {
             'User-Agent': buildUserAgent(this.config.version),
@@ -211,7 +259,7 @@ To authenticate, open the following URL in any browser:
         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,
             }));
@@ -308,7 +356,7 @@ To authenticate, open the following URL in any browser:
             process.stdin.on('error', () => resolve(data.trim()));
         });
     }
-    async resolveBranch(branches, flagValue) {
+    async resolveBranch(branches, flagValue, nonInteractive) {
         if (flagValue !== undefined) {
             // An empty value means "skip and use live branch" (same as the picker's skip option)
             if (flagValue.trim() === '') {
@@ -322,20 +370,39 @@ To authenticate, open the following URL in any browser:
             this.log(`Using branch: ${match.label}`);
             return match.id;
         }
+        if (nonInteractive) {
+            this.log('Using live branch (non-interactive; pass --branch to select one)');
+            return undefined;
+        }
         return branches.length > 1 ? this.selectBranch(branches) : undefined;
     }
-    async resolveInstance(instances, flagValue) {
+    async resolveInstance(instances, flagValue, nonInteractive) {
         if (flagValue) {
-            const match = instances.find((inst) => inst.name === flagValue || inst.id === flagValue);
+            const match = matchInstance(instances, flagValue);
             if (!match) {
-                this.error(`Instance '${flagValue}' not found. Available instances: ${instances.map((inst) => inst.name).join(', ')}`);
+                this.error(`Instance '${flagValue}' not found (match by name, numeric ID, or instance URL). Available instances: ${instances.map((inst) => `${inst.name} (${inst.id})`).join(', ')}`);
             }
             this.log(`Using instance: ${match.name} (${match.display})`);
             return match;
         }
+        if (nonInteractive) {
+            if (instances.length === 1) {
+                this.log(`Using instance: ${instances[0].name} (${instances[0].display})`);
+                return instances[0];
+            }
+            this.error(`Multiple instances available; pass --instance to select one. Available instances: ${instances.map((inst) => `${inst.name} (${inst.id})`).join(', ')}`);
+        }
         return this.selectInstance(instances);
     }
-    async resolveWorkspace(workspaces, flagValue) {
+    async resolveProfileName(flagValue, nonInteractive) {
+        // An empty --profile value means "use the default name" (same as accepting the prompt's default);
+        // non-interactive runs with no --profile fall back to the default name too.
+        if (flagValue !== undefined) {
+            return flagValue.trim() || 'default';
+        }
+        return nonInteractive ? 'default' : this.promptProfileName();
+    }
+    async resolveWorkspace(workspaces, flagValue, nonInteractive) {
         if (flagValue !== undefined) {
             // An empty value means "skip workspace" (same as the picker's skip option)
             if (flagValue.trim() === '') {
@@ -349,8 +416,35 @@ To authenticate, open the following URL in any browser:
             this.log(`Using workspace: ${match.name} (${match.id})`);
             return match;
         }
+        if (nonInteractive) {
+            this.log('Skipping workspace selection (non-interactive; pass --workspace to select one)');
+            return undefined;
+        }
         return this.selectWorkspace(workspaces);
     }
+    async resolveWorkspaceAndBranch(token, instanceOrigin, flags, nonInteractive) {
+        let workspace;
+        let branch;
+        this.log('');
+        this.log('Fetching available workspaces...');
+        const workspaces = await this.fetchWorkspaces(token, instanceOrigin);
+        if (workspaces.length > 0) {
+            workspace = await this.resolveWorkspace(workspaces, flags.workspace, nonInteractive);
+            if (workspace) {
+                this.log('');
+                this.log('Fetching available branches...');
+                const branches = await this.fetchBranches(token, instanceOrigin, workspace.id);
+                branch = await this.resolveBranch(branches, flags.branch, nonInteractive);
+            }
+        }
+        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.');
+        }
+        return { branch, workspace };
+    }
     async saveProfile(profile, configPath) {
         const credentialsPath = resolveCredentialsPath(configPath);
         const credDir = dirname(credentialsPath);
@@ -390,6 +484,7 @@ To authenticate, open the following URL in any browser:
             noRefs: true,
         });
         fs.writeFileSync(credentialsPath, yamlContent, 'utf8');
+        return credentialsPath;
     }
     async selectBranch(branches) {
         const { selectedBranch } = await inquirer.prompt([

package/dist/commands/function/run/index.d.ts

@@ -0,0 +1,40 @@
+import BaseCommand from '../../../base-command.js';
+export default class FunctionRun extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        data: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        logs: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-input-check': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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>;
+    private emitResult;
+    /**
+     * Fetch a single function record by name via the list endpoint's search,
+     * returning the exact-name match (so `calc` doesn't accidentally match
+     * `calcScore`). Best-effort: returns undefined and warns on any failure so a
+     * transient introspection problem never blocks an otherwise-valid run.
+     */
+    private fetchFunctionByName;
+    /**
+     * Prompt for each missing required input on an interactive TTY. Values are
+     * read as raw JSON when they parse as such (so numbers/bools/objects work),
+     * otherwise treated as a string — mirroring the `key:=`/`key=` distinction.
+     * Non-TTY: fail fast with the list of missing params (never hang on a prompt).
+     */
+    private promptForMissing;
+    private readStdinSync;
+    private resolveWorkspaceId;
+}