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

package/README.md

@@ -47,6 +47,13 @@ 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
@@ -55,6 +62,22 @@ 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),
+`-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.

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

@@ -3,10 +3,14 @@ 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;
@@ -15,6 +19,10 @@ export default class Auth extends Command {
     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

@@ -23,8 +23,17 @@ 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)`,
+        `$ 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)',
@@ -36,6 +45,11 @@ To authenticate, open the following URL in any browser:
             default: false,
             description: 'Skip TLS certificate verification (for self-signed certificates)',
         }),
+        instance: Flags.string({
+            char: 'i',
+            description: 'Pre-select an instance by name (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)',
@@ -45,6 +59,16 @@ To authenticate, open the following URL in any browser:
             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);
@@ -69,6 +93,9 @@ To authenticate, open the following URL in any browser:
             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',
@@ -83,7 +110,7 @@ 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.selectInstance(instances);
+                instance = await this.resolveInstance(instances, flags.instance);
             }
             // Step 4: Workspace selection
             let workspace;
@@ -92,20 +119,25 @@ To authenticate, open the following URL in any browser:
             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,
@@ -218,6 +250,17 @@ 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);
         }
@@ -254,6 +297,60 @@ To authenticate, open the following URL in any browser:
         ]);
         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) {
+            const match = instances.find((inst) => inst.name === flagValue || inst.id === flagValue);
+            if (!match) {
+                this.error(`Instance '${flagValue}' not found. Available instances: ${instances.map((inst) => inst.name).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);