@xano/cli 0.0.21 → 0.0.23

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

@@ -2,16 +2,6 @@ import { Flags } from '@oclif/core';
 import BaseRunCommand from '../../../../lib/base-run-command.js';
 export default class RunEnvList extends BaseRunCommand {
     static args = {};
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'list',
-            options: ['list', 'json'],
-        }),
-    };
     static description = 'List all environment variable keys';
     static examples = [
         `$ xano run env list
@@ -24,6 +14,16 @@ Environment variables:
 { "env": ["API_KEY", "DATABASE_URL", "DEBUG"] }
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'list',
+            description: 'Output format',
+            options: ['list', 'json'],
+            required: false,
+        }),
+    };
     async run() {
         const { flags } = await this.parse(RunEnvList);
         // Initialize with project required
@@ -34,15 +34,13 @@ Environment variables:
             if (flags.output === 'json') {
                 this.outputJson(result);
             }
+            else if (result.env.length === 0) {
+                this.log('No environment variables found.');
+            }
             else {
-                if (result.env.length === 0) {
-                    this.log('No environment variables found.');
-                }
-                else {
-                    this.log('Environment variables:');
-                    for (const key of result.env) {
-                        this.log(`  - ${key}`);
-                    }
+                this.log('Environment variables:');
+                for (const key of result.env) {
+                    this.log(`  - ${key}`);
                 }
             }
         }

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

@@ -4,11 +4,11 @@ export default class RunEnvSet extends BaseRunCommand {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
+    static examples: string[];
     static flags: {
         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/set/index.js

@@ -11,9 +11,6 @@ export default class RunEnvSet extends BaseRunCommand {
             required: true,
         }),
     };
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-    };
     static description = 'Set an environment variable';
     static examples = [
         `$ xano run env set API_KEY my-secret-key
@@ -23,16 +20,19 @@ Environment variable 'API_KEY' set successfully!
 Environment variable 'DATABASE_URL' set successfully!
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+    };
     async run() {
         const { args, flags } = await this.parse(RunEnvSet);
         // Initialize with project required
         await this.initRunCommandWithProject(flags.profile, flags.verbose);
         const input = {
-            name: args.name,
             env: {
                 name: args.name,
                 value: args.value,
             },
+            name: args.name,
         };
         try {
             const url = this.httpClient.buildProjectUrl('/env');

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

@@ -3,29 +3,29 @@ export default class RunExec extends BaseRunCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
+    static description: string;
+    static examples: string[];
     static flags: {
-        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        edit: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         args: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        edit: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        stdin: 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>;
-    /**
-     * Load all .xs files from a directory and combine them into a multidoc.
-     */
-    private loadMultidocFromDirectory;
     /**
      * Recursively collect all .xs files from a directory, sorted for deterministic ordering.
      */
     private collectFiles;
-    private outputSummary;
     private editFile;
     private isUrl;
+    /**
+     * Load all .xs files from a directory and combine them into a multidoc.
+     */
+    private loadMultidocFromDirectory;
+    private outputSummary;
     private readStdin;
 }

package/dist/commands/run/exec/index.js

@@ -11,45 +11,6 @@ export default class RunExec extends BaseRunCommand {
             required: false,
         }),
     };
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        file: Flags.string({
-            char: 'f',
-            description: 'Path or URL to file containing XanoScript code (deprecated: use path argument instead)',
-            required: false,
-            exclusive: ['stdin'],
-        }),
-        stdin: Flags.boolean({
-            char: 's',
-            description: 'Read XanoScript code from stdin',
-            required: false,
-            default: false,
-            exclusive: ['file'],
-        }),
-        edit: Flags.boolean({
-            char: 'e',
-            description: 'Open file in editor before running (requires path argument or --file)',
-            required: false,
-            default: false,
-        }),
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-        args: Flags.string({
-            char: 'a',
-            description: 'Path or URL to JSON file containing input arguments',
-            required: false,
-        }),
-        env: Flags.string({
-            description: 'Environment variable override (key=value)',
-            required: false,
-            multiple: true,
-        }),
-    };
     static description = 'Execute XanoScript code (job or service)';
     static examples = [
         `$ xano run exec script.xs
@@ -86,6 +47,45 @@ Executed successfully!
 ...
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        args: Flags.string({
+            char: 'a',
+            description: 'Path or URL to JSON file containing input arguments',
+            required: false,
+        }),
+        edit: Flags.boolean({
+            char: 'e',
+            default: false,
+            description: 'Open file in editor before running (requires path argument or --file)',
+            required: false,
+        }),
+        env: Flags.string({
+            description: 'Environment variable override (key=value)',
+            multiple: true,
+            required: false,
+        }),
+        file: Flags.string({
+            char: 'f',
+            description: 'Path or URL to file containing XanoScript code (deprecated: use path argument instead)',
+            exclusive: ['stdin'],
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        stdin: Flags.boolean({
+            char: 's',
+            default: false,
+            description: 'Read XanoScript code from stdin',
+            exclusive: ['file'],
+            required: false,
+        }),
+    };
     async run() {
         const { args, flags } = await this.parse(RunExec);
         // Initialize with project required
@@ -238,6 +238,74 @@ Executed successfully!
             }
         }
     }
+    /**
+     * Recursively collect all .xs files from a directory, sorted for deterministic ordering.
+     */
+    collectFiles(dir) {
+        const files = [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...this.collectFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.xs')) {
+                files.push(fullPath);
+            }
+        }
+        return files.sort();
+    }
+    // Editor value comes from EDITOR/VISUAL environment variables, not user input
+    async editFile(filePath) {
+        const editor = process.env.EDITOR || process.env.VISUAL;
+        if (!editor) {
+            this.error('No editor configured. Please set the EDITOR or VISUAL environment variable.\n' +
+                'Example: export EDITOR=vim');
+        }
+        // Validate editor executable exists
+        try {
+            execSync(`which ${editor.split(' ')[0]}`, { stdio: 'ignore' });
+        }
+        catch {
+            this.error(`Editor '${editor}' not found. Please set EDITOR to a valid editor.\n` +
+                'Example: export EDITOR=vim');
+        }
+        // Read the original file
+        let originalContent;
+        try {
+            originalContent = fs.readFileSync(filePath, 'utf8');
+        }
+        catch (error) {
+            this.error(`Failed to read file '${filePath}': ${error}`);
+        }
+        // Create a temporary file with the same extension
+        const ext = path.extname(filePath);
+        const tmpFile = path.join(os.tmpdir(), `xano-edit-${Date.now()}${ext}`);
+        // Copy content to temp file
+        try {
+            fs.writeFileSync(tmpFile, originalContent, 'utf8');
+        }
+        catch (error) {
+            this.error(`Failed to create temporary file: ${error}`);
+        }
+        // Open the editor
+        try {
+            execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            this.error(`Editor exited with an error: ${error}`);
+        }
+        return tmpFile;
+    }
+    isUrl(str) {
+        return str.startsWith('http://') || str.startsWith('https://');
+    }
     /**
      * Load all .xs files from a directory and combine them into a multidoc.
      */
@@ -263,23 +331,6 @@ Executed successfully!
         }
         return documents.join('\n---\n');
     }
-    /**
-     * Recursively collect all .xs files from a directory, sorted for deterministic ordering.
-     */
-    collectFiles(dir) {
-        const files = [];
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                files.push(...this.collectFiles(fullPath));
-            }
-            else if (entry.isFile() && entry.name.endsWith('.xs')) {
-                files.push(fullPath);
-            }
-        }
-        return files.sort();
-    }
     outputSummary(result) {
         this.log('Executed successfully!');
         this.log('');
@@ -294,7 +345,7 @@ Executed successfully!
             this.log(`  Run ID:     ${result.run.id}`);
         }
         if (result.run?.session) {
-            const session = result.run.session;
+            const { session } = result.run;
             this.log(`  Session ID: ${session.id}`);
             this.log(`  State:      ${session.state}`);
             this.log('');
@@ -302,7 +353,7 @@ Executed successfully!
         // Handle timing info
         const timing = result.run?.result || result.run?.session || result.result;
         if (timing) {
-            const formatTime = (time) => time !== undefined ? `${(time * 1000).toFixed(2)}ms` : undefined;
+            const formatTime = (time) => time === undefined ? undefined : `${(time * 1000).toFixed(2)}ms`;
             const times = [
                 { label: 'Total', value: formatTime(timing.total_time) },
                 { label: 'Boot', value: formatTime(timing.boot_time) },
@@ -362,57 +413,6 @@ Executed successfully!
             this.log(`  Error: ${result.run.session.error_msg}`);
         }
     }
-    // Editor value comes from EDITOR/VISUAL environment variables, not user input
-    async editFile(filePath) {
-        const editor = process.env.EDITOR || process.env.VISUAL;
-        if (!editor) {
-            this.error('No editor configured. Please set the EDITOR or VISUAL environment variable.\n' +
-                'Example: export EDITOR=vim');
-        }
-        // Validate editor executable exists
-        try {
-            execSync(`which ${editor.split(' ')[0]}`, { stdio: 'ignore' });
-        }
-        catch {
-            this.error(`Editor '${editor}' not found. Please set EDITOR to a valid editor.\n` +
-                'Example: export EDITOR=vim');
-        }
-        // Read the original file
-        let originalContent;
-        try {
-            originalContent = fs.readFileSync(filePath, 'utf8');
-        }
-        catch (error) {
-            this.error(`Failed to read file '${filePath}': ${error}`);
-        }
-        // Create a temporary file with the same extension
-        const ext = path.extname(filePath);
-        const tmpFile = path.join(os.tmpdir(), `xano-edit-${Date.now()}${ext}`);
-        // Copy content to temp file
-        try {
-            fs.writeFileSync(tmpFile, originalContent, 'utf8');
-        }
-        catch (error) {
-            this.error(`Failed to create temporary file: ${error}`);
-        }
-        // Open the editor
-        try {
-            execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
-        }
-        catch (error) {
-            try {
-                fs.unlinkSync(tmpFile);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-            this.error(`Editor exited with an error: ${error}`);
-        }
-        return tmpFile;
-    }
-    isUrl(str) {
-        return str.startsWith('http://') || str.startsWith('https://');
-    }
     async readStdin() {
         return new Promise((resolve, reject) => {
             const chunks = [];

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

@@ -1,17 +1,17 @@
 import BaseRunCommand from '../../../lib/base-run-command.js';
 export default class RunInfo extends BaseRunCommand {
     static args: {};
+    static description: string;
+    static examples: string[];
     static flags: {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        stdin: 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>;
         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>;
-    private outputSummary;
     private isUrl;
+    private outputSummary;
     private readStdin;
 }

package/dist/commands/run/info/index.js

@@ -3,29 +3,6 @@ import * as fs from 'node:fs';
 import BaseRunCommand from '../../../lib/base-run-command.js';
 export default class RunInfo extends BaseRunCommand {
     static args = {};
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        file: Flags.string({
-            char: 'f',
-            description: 'Path or URL to file containing XanoScript code',
-            required: false,
-            exclusive: ['stdin'],
-        }),
-        stdin: Flags.boolean({
-            char: 's',
-            description: 'Read XanoScript code from stdin',
-            required: false,
-            default: false,
-            exclusive: ['file'],
-        }),
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-    };
     static description = 'Get information about a XanoScript document (type, inputs, env vars)';
     static examples = [
         `$ xano run info -f script.xs
@@ -48,6 +25,29 @@ Document Info:
 { "type": "job", "input": { "name": {...} }, "env": ["API_KEY"] }
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        file: Flags.string({
+            char: 'f',
+            description: 'Path or URL to file containing XanoScript code',
+            exclusive: ['stdin'],
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        stdin: Flags.boolean({
+            char: 's',
+            default: false,
+            description: 'Read XanoScript code from stdin',
+            exclusive: ['file'],
+            required: false,
+        }),
+    };
     async run() {
         const { flags } = await this.parse(RunInfo);
         // Initialize with project required
@@ -112,6 +112,9 @@ Document Info:
             }
         }
     }
+    isUrl(str) {
+        return str.startsWith('http://') || str.startsWith('https://');
+    }
     outputSummary(result) {
         this.log('Document Info:');
         this.log(`  Type: ${result.type}`);
@@ -139,9 +142,6 @@ Document Info:
             this.log('    (none)');
         }
     }
-    isUrl(str) {
-        return str.startsWith('http://') || str.startsWith('https://');
-    }
     async readStdin() {
         return new Promise((resolve, reject) => {
             const chunks = [];

package/dist/commands/run/projects/create/index.d.ts

@@ -1,14 +1,14 @@
 import BaseRunCommand from '../../../../lib/base-run-command.js';
 export default class RunProjectsCreate extends BaseRunCommand {
     static args: {};
+    static description: string;
+    static examples: string[];
     static flags: {
-        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         description: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         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>;
 }

package/dist/commands/run/projects/create/index.js

@@ -2,27 +2,6 @@ import { Flags } from '@oclif/core';
 import BaseRunCommand from '../../../../lib/base-run-command.js';
 export default class RunProjectsCreate extends BaseRunCommand {
     static args = {};
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        name: Flags.string({
-            char: 'n',
-            description: 'Project name',
-            required: true,
-        }),
-        description: Flags.string({
-            char: 'd',
-            description: 'Project description',
-            required: false,
-            default: '',
-        }),
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-    };
     static description = 'Create a new project';
     static examples = [
         `$ xano run projects create -n "My Project"
@@ -39,13 +18,34 @@ Project created successfully!
 { "id": "abc123-def456-ghi789", "name": "My Project", ... }
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'Project description',
+            required: false,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Project name',
+            required: true,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+    };
     async run() {
         const { flags } = await this.parse(RunProjectsCreate);
         // Initialize (no project required for creating projects)
         await this.initRunCommand(flags.profile, flags.verbose);
         const input = {
-            name: flags.name,
             description: flags.description || '',
+            name: flags.name,
         };
         try {
             const url = this.httpClient.buildUrl('/project');

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

@@ -3,12 +3,12 @@ export default class RunProjectsDelete extends BaseRunCommand {
     static args: {
         projectId: 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/projects/delete/index.js

@@ -7,15 +7,6 @@ export default class RunProjectsDelete extends BaseRunCommand {
             required: true,
         }),
     };
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        force: Flags.boolean({
-            char: 'f',
-            description: 'Skip confirmation prompt',
-            required: false,
-            default: false,
-        }),
-    };
     static description = 'Delete a project';
     static examples = [
         `$ xano run projects delete abc123-def456
@@ -26,6 +17,15 @@ Project deleted successfully!
 Project 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(RunProjectsDelete);
         // Initialize (no project required)

package/dist/commands/run/projects/list/index.d.ts

@@ -1,13 +1,13 @@
 import BaseRunCommand from '../../../../lib/base-run-command.js';
 export default class RunProjectsList extends BaseRunCommand {
     static args: {};
+    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>;
     private outputTable;
 }