@xano/cli 0.0.26 → 0.0.28

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

@@ -7,16 +7,6 @@ export default class RunEnvGet extends BaseRunCommand {
             required: true,
         }),
     };
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'value',
-            options: ['value', 'json'],
-        }),
-    };
     static description = 'Get an environment variable value';
     static examples = [
         `$ xano run env get API_KEY
@@ -26,10 +16,20 @@ my-secret-api-key
 { "name": "API_KEY", "value": "my-secret-api-key" }
 `,
     ];
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'value',
+            description: 'Output format',
+            options: ['value', 'json'],
+            required: false,
+        }),
+    };
     async run() {
         const { args, flags } = await this.parse(RunEnvGet);
         // Initialize with project required
-        await this.initRunCommandWithProject(flags.profile);
+        await this.initRunCommandWithProject(flags.profile, flags.verbose);
         try {
             const url = this.httpClient.buildProjectUrl('/env', { name: args.name });
             const result = await this.httpClient.get(url);

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

@@ -1,11 +1,12 @@
 import BaseRunCommand from '../../../../lib/base-run-command.js';
 export default class RunEnvList 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>;
 }

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,25 +14,33 @@ 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
-        await this.initRunCommandWithProject(flags.profile);
+        await this.initRunCommandWithProject(flags.profile, flags.verbose);
         try {
             const url = this.httpClient.buildProjectUrl('/env/key');
             const result = await this.httpClient.get(url);
             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,10 +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);
+        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

@@ -1,20 +1,31 @@
 import BaseRunCommand from '../../../lib/base-run-command.js';
 export default class RunExec extends BaseRunCommand {
-    static args: {};
+    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>;
-    private outputSummary;
+    /**
+     * Recursively collect all .xs files from a directory, sorted for deterministic ordering.
+     */
+    private collectFiles;
     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

@@ -1,58 +1,28 @@
-import { Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { execSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import BaseRunCommand from '../../../lib/base-run-command.js';
 export default class RunExec extends BaseRunCommand {
-    static args = {};
-    static flags = {
-        ...BaseRunCommand.baseFlags,
-        file: Flags.string({
-            char: 'f',
-            description: 'Path or URL to file containing XanoScript code',
+    static args = {
+        path: Args.string({
+            description: 'Path to file or directory containing XanoScript code (directory creates multidoc from .xs files)',
             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 --file)',
-            required: false,
-            default: false,
-            dependsOn: ['file'],
-        }),
-        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 -f script.xs
+        `$ xano run exec script.xs
+Executed successfully!
+...
+`,
+        `$ xano run exec ./my-workspace
+# Executes all .xs files in directory as multidoc
 Executed successfully!
 ...
 `,
-        `$ xano run exec -f script.xs --edit
+        `$ xano run exec script.xs --edit
 # Opens script.xs in $EDITOR, then executes
 Executed successfully!
 ...
@@ -61,45 +31,102 @@ Executed successfully!
 Executed successfully!
 ...
 `,
-        `$ xano run exec -f script.xs -o json
+        `$ xano run exec script.xs -o json
 {
   "run": { ... }
 }
 `,
-        `$ xano run exec -f script.xs -a args.json
+        `$ xano run exec script.xs -a args.json
 # Executes with input arguments from args.json
 Executed successfully!
 ...
 `,
-        `$ xano run exec -f script.xs --env API_KEY=secret --env DEBUG=true
+        `$ xano run exec script.xs --env API_KEY=secret --env DEBUG=true
 # Executes with environment variable overrides
 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 { flags } = await this.parse(RunExec);
+        const { args, flags } = await this.parse(RunExec);
         // Initialize with project required
-        await this.initRunCommandWithProject(flags.profile);
+        await this.initRunCommandWithProject(flags.profile, flags.verbose);
+        // Determine input source: path argument, --file flag, or --stdin
+        const inputPath = args.path || flags.file;
+        // Validate --edit flag requirements
+        if (flags.edit) {
+            if (!inputPath) {
+                this.error('--edit requires a file path (either path argument or --file flag)');
+            }
+            if (this.isUrl(inputPath)) {
+                this.error('--edit cannot be used with URLs');
+            }
+            if (fs.existsSync(inputPath) && fs.statSync(inputPath).isDirectory()) {
+                this.error('--edit cannot be used with directories');
+            }
+        }
         // Read XanoScript content
         let xanoscript;
-        if (flags.file) {
-            if (this.isUrl(flags.file)) {
+        if (inputPath) {
+            if (this.isUrl(inputPath)) {
                 // Fetch URL content
                 try {
-                    const response = await fetch(flags.file);
+                    const response = await fetch(inputPath);
                     if (!response.ok) {
                         this.error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
                     }
                     xanoscript = await response.text();
                 }
                 catch (error) {
-                    this.error(`Failed to fetch URL '${flags.file}': ${error}`);
+                    this.error(`Failed to fetch URL '${inputPath}': ${error}`);
                 }
             }
+            else if (fs.existsSync(inputPath) && fs.statSync(inputPath).isDirectory()) {
+                // Handle directory - collect .xs files and create multidoc
+                xanoscript = this.loadMultidocFromDirectory(inputPath);
+            }
             else if (flags.edit) {
                 // If edit flag is set, copy to temp file and open in editor
-                const fileToRead = await this.editFile(flags.file);
+                const fileToRead = await this.editFile(inputPath);
                 xanoscript = fs.readFileSync(fileToRead, 'utf8');
                 // Clean up temp file
                 try {
@@ -111,10 +138,10 @@ Executed successfully!
             }
             else {
                 try {
-                    xanoscript = fs.readFileSync(flags.file, 'utf8');
+                    xanoscript = fs.readFileSync(inputPath, 'utf8');
                 }
                 catch (error) {
-                    this.error(`Failed to read file '${flags.file}': ${error}`);
+                    this.error(`Failed to read file '${inputPath}': ${error}`);
                 }
             }
         }
@@ -127,7 +154,7 @@ Executed successfully!
             }
         }
         else {
-            this.error('Either --file or --stdin must be specified to provide XanoScript code');
+            this.error('Either a path argument, --file, or --stdin must be specified to provide XanoScript code');
         }
         // Validate xanoscript is not empty
         if (!xanoscript || xanoscript.trim().length === 0) {
@@ -195,13 +222,115 @@ Executed successfully!
         }
         catch (error) {
             if (error instanceof Error) {
-                this.error(`Failed to execute: ${error.message}`);
+                const xanoError = error;
+                if (xanoError.response) {
+                    const responseStr = typeof xanoError.response === 'string'
+                        ? xanoError.response
+                        : JSON.stringify(xanoError.response, null, 2);
+                    this.error(`Failed to execute: ${error.message}\n\n${responseStr}`);
+                }
+                else {
+                    this.error(`Failed to execute: ${error.message}`);
+                }
             }
             else {
                 this.error(`Failed to execute: ${String(error)}`);
             }
         }
     }
+    /**
+     * 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.
+     */
+    loadMultidocFromDirectory(dir) {
+        const resolvedDir = path.resolve(dir);
+        if (!fs.existsSync(resolvedDir)) {
+            this.error(`Directory not found: ${resolvedDir}`);
+        }
+        const files = this.collectFiles(resolvedDir);
+        if (files.length === 0) {
+            this.error(`No .xs files found in ${dir}`);
+        }
+        // Read each file and join with --- separator
+        const documents = [];
+        for (const filePath of files) {
+            const content = fs.readFileSync(filePath, 'utf8').trim();
+            if (content) {
+                documents.push(content);
+            }
+        }
+        if (documents.length === 0) {
+            this.error(`All .xs files in ${dir} are empty`);
+        }
+        return documents.join('\n---\n');
+    }
     outputSummary(result) {
         this.log('Executed successfully!');
         this.log('');
@@ -216,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('');
@@ -224,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) },
@@ -284,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,16 +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;
 }