@xano/cli 0.0.26 → 0.0.28

package/dist/commands/profile/me/index.js

@@ -1,20 +1,10 @@
 import { Flags } 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 * as yaml from 'js-yaml';
 import BaseCommand from '../../../base-command.js';
 export default class ProfileMe extends BaseCommand {
-    static flags = {
-        ...BaseCommand.baseFlags,
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-    };
     static description = 'Get information about the currently authenticated user';
     static examples = [
         `$ xano profile:me
@@ -37,6 +27,16 @@ User Information:
 }
 `,
     ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+    };
     async run() {
         const { flags } = await this.parse(ProfileMe);
         // Get profile name (default or from flag/env)
@@ -61,11 +61,11 @@ User Information:
         // Fetch user info from the API
         try {
             const response = await fetch(apiUrl, {
-                method: 'GET',
                 headers: {
                     'accept': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,
                 },
+                method: 'GET',
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -93,9 +93,9 @@ User Information:
                     this.log(`  Created: ${date.toISOString()}`);
                 }
                 // Display any other fields that aren't already shown
-                const knownFields = ['id', 'name', 'email', 'created_at'];
+                const knownFields = new Set(['created_at', 'email', 'id', 'name']);
                 for (const [key, value] of Object.entries(data)) {
-                    if (!knownFields.includes(key) && value !== null && value !== undefined) {
+                    if (!knownFields.has(key) && value !== null && value !== undefined) {
                         if (typeof value === 'object') {
                             this.log(`  ${this.formatKey(key)}: ${JSON.stringify(value)}`);
                         }
@@ -115,6 +115,13 @@ User Information:
             }
         }
     }
+    formatKey(key) {
+        // Convert snake_case to Title Case
+        return key
+            .split('_')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
     loadCredentials() {
         const configDir = path.join(os.homedir(), '.xano');
         const credentialsPath = path.join(configDir, 'credentials.yaml');
@@ -136,11 +143,4 @@ User Information:
             this.error(`Failed to parse credentials file: ${error}`);
         }
     }
-    formatKey(key) {
-        // Convert snake_case to Title Case
-        return key
-            .split('_')
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-            .join(' ');
-    }
 }

package/dist/commands/profile/project/index.js

@@ -1,8 +1,8 @@
 import { Command } 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 * as yaml from 'js-yaml';
 export default class ProfileProject extends Command {
     static description = 'Print the project for the default profile';
     static examples = [

package/dist/commands/profile/set-default/index.js

@@ -1,8 +1,8 @@
 import { Args, Command } 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 * as yaml from 'js-yaml';
 export default class ProfileSetDefault extends Command {
     static args = {
         name: Args.string({

package/dist/commands/profile/token/index.js

@@ -1,8 +1,8 @@
 import { Command } 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 * as yaml from 'js-yaml';
 export default class ProfileToken extends Command {
     static description = 'Print the access token for the default profile';
     static examples = [

package/dist/commands/profile/wizard/index.d.ts

@@ -1,16 +1,17 @@
 import { Command } from '@oclif/core';
 export default class ProfileWizard extends Command {
+    static description: string;
+    static examples: string[];
     static flags: {
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         origin: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static description: string;
-    static examples: string[];
     run(): Promise<void>;
-    private fetchInstances;
-    private fetchWorkspaces;
     private fetchBranches;
+    private fetchInstances;
     private fetchProjects;
+    private fetchRunProjects;
+    private fetchWorkspaces;
     private getDefaultProfileName;
     private saveProfile;
 }

package/dist/commands/profile/wizard/index.js

@@ -1,23 +1,11 @@
 import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+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 * as yaml from 'js-yaml';
-import inquirer from 'inquirer';
+import { DEFAULT_RUN_BASE_URL } from '../../../lib/run-http-client.js';
 export default class ProfileWizard extends Command {
-    static flags = {
-        name: Flags.string({
-            char: 'n',
-            description: 'Profile name (skip prompt if provided)',
-            required: false,
-        }),
-        origin: Flags.string({
-            char: 'o',
-            description: 'Xano instance origin URL',
-            required: false,
-            default: 'https://app.xano.com',
-        }),
-    };
     static description = 'Create a new profile configuration using an interactive wizard';
     static examples = [
         `$ xano profile:wizard
@@ -30,6 +18,19 @@ Welcome to the Xano Profile Wizard!
 Profile 'production' created successfully at ~/.xano/credentials.yaml
 `,
     ];
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Profile name (skip prompt if provided)',
+            required: false,
+        }),
+        origin: Flags.string({
+            char: 'o',
+            default: 'https://app.xano.com',
+            description: 'Xano instance origin URL',
+            required: false,
+        }),
+    };
     async run() {
         const { flags } = await this.parse(ProfileWizard);
         this.log('Welcome to the Xano Profile Wizard!');
@@ -38,11 +39,11 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             // Step 1: Get access token
             const { accessToken } = await inquirer.prompt([
                 {
-                    type: 'password',
-                    name: 'accessToken',
-                    message: 'Enter your access token',
                     mask: '',
-                    validate: (input) => {
+                    message: 'Enter your access token',
+                    name: 'accessToken',
+                    type: 'password',
+                    validate(input) {
                         if (!input || input.trim() === '') {
                             return 'Access token cannot be empty';
                         }
@@ -67,13 +68,13 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             this.log('');
             const { instanceId } = await inquirer.prompt([
                 {
-                    type: 'list',
-                    name: 'instanceId',
-                    message: 'Select an instance',
                     choices: instances.map((inst) => ({
                         name: `${inst.name} (${inst.display})`,
                         value: inst.id,
                     })),
+                    message: 'Select an instance',
+                    name: 'instanceId',
+                    type: 'list',
                 },
             ]);
             const selectedInstance = instances.find((inst) => inst.id === instanceId);
@@ -81,11 +82,11 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             const defaultProfileName = flags.name || this.getDefaultProfileName();
             const { profileName } = await inquirer.prompt([
                 {
-                    type: 'input',
-                    name: 'profileName',
-                    message: 'Profile name',
                     default: defaultProfileName,
-                    validate: (input) => {
+                    message: 'Profile name',
+                    name: 'profileName',
+                    type: 'input',
+                    validate(input) {
                         if (!input || input.trim() === '') {
                             return 'Profile name cannot be empty';
                         }
@@ -112,9 +113,6 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
                 this.log('');
                 const { selectedWorkspace } = await inquirer.prompt([
                     {
-                        type: 'list',
-                        name: 'selectedWorkspace',
-                        message: 'Select a workspace (or skip to use default)',
                         choices: [
                             { name: '(Skip workspace)', value: '' },
                             ...workspaces.map((ws) => ({
@@ -122,6 +120,9 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
                                 value: ws.id,
                             })),
                         ],
+                        message: 'Select a workspace (or skip to use default)',
+                        name: 'selectedWorkspace',
+                        type: 'list',
                     },
                 ]);
                 workspace = selectedWorkspace || undefined;
@@ -142,18 +143,16 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
                         this.log('');
                         const { selectedBranch } = await inquirer.prompt([
                             {
-                                type: 'list',
-                                name: 'selectedBranch',
-                                message: 'Select a branch',
                                 choices: [
                                     { name: '(Skip and use live branch)', value: '' },
-                                    ...branches.map((br) => {
-                                        return {
-                                            name: br.label,
-                                            value: br.id,
-                                        };
-                                    }),
+                                    ...branches.map((br) => ({
+                                        name: br.label,
+                                        value: br.id,
+                                    })),
                                 ],
+                                message: 'Select a branch',
+                                name: 'selectedBranch',
+                                type: 'list',
                             },
                         ]);
                         branch = selectedBranch || undefined;
@@ -173,33 +172,50 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
                         this.log('');
                         const { selectedProject } = await inquirer.prompt([
                             {
-                                type: 'list',
-                                name: 'selectedProject',
-                                message: 'Select a project',
                                 choices: [
                                     { name: '(Skip project)', value: '' },
-                                    ...projects.map((proj) => {
-                                        return {
-                                            name: proj.name,
-                                            value: proj.id,
-                                        };
-                                    }),
+                                    ...projects.map((proj) => ({
+                                        name: proj.name,
+                                        value: proj.id,
+                                    })),
                                 ],
+                                message: 'Select a project',
+                                name: 'selectedProject',
+                                type: 'list',
                             },
                         ]);
                         project = selectedProject || undefined;
                     }
                 }
             }
+            // Step 7: Fetch run projects and auto-select the first one if no project was selected
+            this.log('');
+            this.log('Fetching available run projects...');
+            try {
+                const runProjects = await this.fetchRunProjects(accessToken);
+                if (runProjects.length > 0) {
+                    // Use run project if no metadata project was selected
+                    if (!project) {
+                        project = runProjects[0].id;
+                    }
+                    this.log(`✓ Found ${runProjects.length} run project(s). Using "${runProjects[0].name}" as default.`);
+                }
+                else {
+                    this.log('No run projects found. You can create one later with "xano run projects create".');
+                }
+            }
+            catch {
+                // Silently ignore - project will remain undefined
+            }
             // Save profile
             await this.saveProfile({
-                name: profileName,
-                account_origin: flags.origin,
-                instance_origin: selectedInstance.origin,
                 access_token: accessToken,
-                workspace,
+                account_origin: flags.origin,
                 branch,
+                instance_origin: selectedInstance.origin,
+                name: profileName,
                 project,
+                workspace,
             }, true);
             this.log('');
             this.log(`✓ Profile '${profileName}' created successfully!`);
@@ -212,13 +228,48 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             throw error;
         }
     }
+    async fetchBranches(accessToken, origin, workspaceId) {
+        const response = await fetch(`${origin}/api:meta/workspace/${workspaceId}/branch`, {
+            headers: {
+                accept: 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error('Unauthorized. Please check your access token.');
+            }
+            throw new Error(`API request failed with status ${response.status}`);
+        }
+        const data = (await response.json());
+        // Transform API response to Branch format
+        // Assuming the API returns an array or object with branches
+        if (Array.isArray(data)) {
+            return data.map((br) => ({
+                id: br.id || br.label,
+                label: br.label,
+            }));
+        }
+        // If it's an object, try to extract branches
+        if (data && typeof data === 'object') {
+            const branches = data.branches || data.data || [];
+            if (Array.isArray(branches)) {
+                return branches.map((br) => ({
+                    id: br.id || br.name,
+                    label: br.label,
+                }));
+            }
+        }
+        return [];
+    }
     async fetchInstances(accessToken, origin) {
         const response = await fetch(`${origin}/api:meta/instance`, {
-            method: 'GET',
             headers: {
                 accept: 'application/json',
                 Authorization: `Bearer ${accessToken}`,
             },
+            method: 'GET',
         });
         if (!response.ok) {
             if (response.status === 401) {
@@ -231,9 +282,9 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
         // Assuming the API returns an array or object with instances
         if (Array.isArray(data)) {
             return data.map((inst) => ({
+                display: inst.display,
                 id: inst.id || inst.name,
                 name: inst.name,
-                display: inst.display,
                 origin: new URL(inst.meta_api).origin,
             }));
         }
@@ -242,22 +293,23 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             const instances = data.instances || data.data || [];
             if (Array.isArray(instances)) {
                 return instances.map((inst) => ({
+                    display: inst.display,
                     id: inst.id || inst.name,
                     name: inst.name,
-                    display: inst.display,
                     origin: new URL(inst.meta_api).origin,
                 }));
             }
         }
         return [];
     }
-    async fetchWorkspaces(accessToken, origin) {
-        const response = await fetch(`${origin}/api:meta/workspace`, {
-            method: 'GET',
+    async fetchProjects(accessToken, origin, workspaceId, branchId) {
+        const branchParam = branchId ? `?branch=${branchId}` : '';
+        const response = await fetch(`${origin}/api:meta/workspace/${workspaceId}/project${branchParam}`, {
             headers: {
                 accept: 'application/json',
                 Authorization: `Bearer ${accessToken}`,
             },
+            method: 'GET',
         });
         if (!response.ok) {
             if (response.status === 401) {
@@ -266,33 +318,34 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             throw new Error(`API request failed with status ${response.status}`);
         }
         const data = (await response.json());
-        // Transform API response to Workspace format
-        // Assuming the API returns an array or object with workspaces
+        // Transform API response to Project format
+        // Assuming the API returns an array or object with projects
         if (Array.isArray(data)) {
-            return data.map((ws) => ({
-                id: ws.id || ws.name,
-                name: ws.name,
+            return data.map((proj) => ({
+                id: proj.id || proj.name,
+                name: proj.name,
             }));
         }
-        // If it's an object, try to extract workspaces
+        // If it's an object, try to extract projects
         if (data && typeof data === 'object') {
-            const workspaces = data.workspaces || data.data || [];
-            if (Array.isArray(workspaces)) {
-                return workspaces.map((ws) => ({
-                    id: ws.id || ws.name,
-                    name: ws.name,
+            const projects = data.projects || data.data || [];
+            if (Array.isArray(projects)) {
+                return projects.map((proj) => ({
+                    id: proj.id || proj.name,
+                    name: proj.name,
                 }));
             }
         }
         return [];
     }
-    async fetchBranches(accessToken, origin, workspaceId) {
-        const response = await fetch(`${origin}/api:meta/workspace/${workspaceId}/branch`, {
-            method: 'GET',
+    async fetchRunProjects(accessToken, runBaseUrl = DEFAULT_RUN_BASE_URL) {
+        const baseUrl = runBaseUrl.endsWith('/') ? runBaseUrl.slice(0, -1) : runBaseUrl;
+        const response = await fetch(`${baseUrl}/api:run/project`, {
             headers: {
-                accept: 'application/json',
                 Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
             },
+            method: 'GET',
         });
         if (!response.ok) {
             if (response.status === 401) {
@@ -301,34 +354,15 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             throw new Error(`API request failed with status ${response.status}`);
         }
         const data = (await response.json());
-        // Transform API response to Branch format
-        // Assuming the API returns an array or object with branches
-        if (Array.isArray(data)) {
-            return data.map((br) => ({
-                id: br.id || br.label,
-                label: br.label,
-            }));
-        }
-        // If it's an object, try to extract branches
-        if (data && typeof data === 'object') {
-            const branches = data.branches || data.data || [];
-            if (Array.isArray(branches)) {
-                return branches.map((br) => ({
-                    id: br.id || br.name,
-                    label: br.label,
-                }));
-            }
-        }
-        return [];
+        return Array.isArray(data) ? data : [];
     }
-    async fetchProjects(accessToken, origin, workspaceId, branchId) {
-        const branchParam = branchId ? `?branch=${branchId}` : '';
-        const response = await fetch(`${origin}/api:meta/workspace/${workspaceId}/project${branchParam}`, {
-            method: 'GET',
+    async fetchWorkspaces(accessToken, origin) {
+        const response = await fetch(`${origin}/api:meta/workspace`, {
             headers: {
                 accept: 'application/json',
                 Authorization: `Bearer ${accessToken}`,
             },
+            method: 'GET',
         });
         if (!response.ok) {
             if (response.status === 401) {
@@ -337,21 +371,21 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
             throw new Error(`API request failed with status ${response.status}`);
         }
         const data = (await response.json());
-        // Transform API response to Project format
-        // Assuming the API returns an array or object with projects
+        // Transform API response to Workspace format
+        // Assuming the API returns an array or object with workspaces
         if (Array.isArray(data)) {
-            return data.map((proj) => ({
-                id: proj.id || proj.name,
-                name: proj.name,
+            return data.map((ws) => ({
+                id: ws.id || ws.name,
+                name: ws.name,
             }));
         }
-        // If it's an object, try to extract projects
+        // If it's an object, try to extract workspaces
         if (data && typeof data === 'object') {
-            const projects = data.projects || data.data || [];
-            if (Array.isArray(projects)) {
-                return projects.map((proj) => ({
-                    id: proj.id || proj.name,
-                    name: proj.name,
+            const workspaces = data.workspaces || data.data || [];
+            if (Array.isArray(workspaces)) {
+                return workspaces.map((ws) => ({
+                    id: ws.id || ws.name,
+                    name: ws.name,
                 }));
             }
         }
@@ -392,15 +426,15 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
                     credentials = parsed;
                 }
             }
-            catch (error) {
+            catch {
                 // Continue with empty credentials if parse fails
             }
         }
         // Add or update the profile
         credentials.profiles[profile.name] = {
+            access_token: profile.access_token,
             account_origin: profile.account_origin,
             instance_origin: profile.instance_origin,
-            access_token: profile.access_token,
             ...(profile.workspace && { workspace: profile.workspace }),
             ...(profile.branch && { branch: profile.branch }),
             ...(profile.project && { project: profile.project }),

package/dist/commands/run/env/delete/index.d.ts

@@ -3,11 +3,12 @@ export default class RunEnvDelete extends BaseRunCommand {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
+    static examples: string[];
     static flags: {
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    static description: string;
-    static examples: string[];
     run(): Promise<void>;
 }

package/dist/commands/run/env/delete/index.js

@@ -7,15 +7,6 @@ export default class RunEnvDelete extends BaseRunCommand {
             required: true,
         }),
     };
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        force: Flags.boolean({
-            char: 'f',
-            description: 'Skip confirmation prompt',
-            required: false,
-            default: false,
-        }),
-    };
     static description = 'Delete an environment variable';
     static examples = [
         `$ xano run env delete API_KEY
@@ -26,10 +17,19 @@ Environment variable 'API_KEY' deleted successfully!
 Environment variable 'API_KEY' deleted successfully!
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt',
+            required: false,
+        }),
+    };
     async run() {
         const { args, flags } = await this.parse(RunEnvDelete);
         // Initialize with project required
-        await this.initRunCommandWithProject(flags.profile);
+        await this.initRunCommandWithProject(flags.profile, flags.verbose);
         // Confirm deletion unless --force is used
         if (!flags.force) {
             const readline = await import('node:readline');

package/dist/commands/run/env/get/index.d.ts

@@ -3,11 +3,12 @@ export default class RunEnvGet extends BaseRunCommand {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
+    static examples: string[];
     static flags: {
         output: import("@oclif/core/interfaces").OptionFlag<string, 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>;
     };
-    static description: string;
-    static examples: string[];
     run(): Promise<void>;
 }