@xano/cli 0.0.25 → 0.0.26

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

@@ -7,6 +7,16 @@ 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
@@ -16,20 +26,10 @@ 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, flags.verbose);
+        await this.initRunCommandWithProject(flags.profile);
         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,12 +1,11 @@
 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,6 +2,16 @@ 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
@@ -14,33 +24,25 @@ 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, flags.verbose);
+        await this.initRunCommandWithProject(flags.profile);
         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 {
-                this.log('Environment variables:');
-                for (const key of result.env) {
-                    this.log(`  - ${key}`);
+                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}`);
+                    }
                 }
             }
         }

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

@@ -4,11 +4,10 @@ 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,6 +11,9 @@ 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
@@ -20,19 +23,16 @@ 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);
+        await this.initRunCommandWithProject(flags.profile);
         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,31 +1,20 @@
 import BaseRunCommand from '../../../lib/base-run-command.js';
 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 args: {};
     static flags: {
-        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>;
+        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>;
+        env: 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>;
     };
+    static description: string;
+    static examples: string[];
     run(): Promise<void>;
-    /**
-     * 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

@@ -1,28 +1,58 @@
-import { Args, Flags } from '@oclif/core';
+import { 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 = {
-        path: Args.string({
-            description: 'Path to file or directory containing XanoScript code (directory creates multidoc from .xs files)',
+    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'],
+        }),
+        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 script.xs
-Executed successfully!
-...
-`,
-        `$ xano run exec ./my-workspace
-# Executes all .xs files in directory as multidoc
+        `$ xano run exec -f script.xs
 Executed successfully!
 ...
 `,
-        `$ xano run exec script.xs --edit
+        `$ xano run exec -f script.xs --edit
 # Opens script.xs in $EDITOR, then executes
 Executed successfully!
 ...
@@ -31,102 +61,45 @@ Executed successfully!
 Executed successfully!
 ...
 `,
-        `$ xano run exec script.xs -o json
+        `$ xano run exec -f script.xs -o json
 {
   "run": { ... }
 }
 `,
-        `$ xano run exec script.xs -a args.json
+        `$ xano run exec -f script.xs -a args.json
 # Executes with input arguments from args.json
 Executed successfully!
 ...
 `,
-        `$ xano run exec script.xs --env API_KEY=secret --env DEBUG=true
+        `$ xano run exec -f 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 { args, flags } = await this.parse(RunExec);
+        const { flags } = await this.parse(RunExec);
         // Initialize with project required
-        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');
-            }
-        }
+        await this.initRunCommandWithProject(flags.profile);
         // Read XanoScript content
         let xanoscript;
-        if (inputPath) {
-            if (this.isUrl(inputPath)) {
+        if (flags.file) {
+            if (this.isUrl(flags.file)) {
                 // Fetch URL content
                 try {
-                    const response = await fetch(inputPath);
+                    const response = await fetch(flags.file);
                     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 '${inputPath}': ${error}`);
+                    this.error(`Failed to fetch URL '${flags.file}': ${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(inputPath);
+                const fileToRead = await this.editFile(flags.file);
                 xanoscript = fs.readFileSync(fileToRead, 'utf8');
                 // Clean up temp file
                 try {
@@ -138,10 +111,10 @@ Executed successfully!
             }
             else {
                 try {
-                    xanoscript = fs.readFileSync(inputPath, 'utf8');
+                    xanoscript = fs.readFileSync(flags.file, 'utf8');
                 }
                 catch (error) {
-                    this.error(`Failed to read file '${inputPath}': ${error}`);
+                    this.error(`Failed to read file '${flags.file}': ${error}`);
                 }
             }
         }
@@ -154,7 +127,7 @@ Executed successfully!
             }
         }
         else {
-            this.error('Either a path argument, --file, or --stdin must be specified to provide XanoScript code');
+            this.error('Either --file or --stdin must be specified to provide XanoScript code');
         }
         // Validate xanoscript is not empty
         if (!xanoscript || xanoscript.trim().length === 0) {
@@ -222,115 +195,13 @@ Executed successfully!
         }
         catch (error) {
             if (error instanceof Error) {
-                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}`);
-                }
+                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('');
@@ -345,7 +216,7 @@ Executed successfully!
             this.log(`  Run ID:     ${result.run.id}`);
         }
         if (result.run?.session) {
-            const { session } = result.run;
+            const session = result.run.session;
             this.log(`  Session ID: ${session.id}`);
             this.log(`  State:      ${session.state}`);
             this.log('');
@@ -353,7 +224,7 @@ Executed successfully!
         // Handle timing info
         const timing = result.run?.result || result.run?.session || result.result;
         if (timing) {
-            const formatTime = (time) => time === undefined ? undefined : `${(time * 1000).toFixed(2)}ms`;
+            const formatTime = (time) => time !== undefined ? `${(time * 1000).toFixed(2)}ms` : undefined;
             const times = [
                 { label: 'Total', value: formatTime(timing.total_time) },
                 { label: 'Boot', value: formatTime(timing.boot_time) },
@@ -413,6 +284,57 @@ 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,16 @@
 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>;
-        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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 isUrl;
     private outputSummary;
+    private isUrl;
     private readStdin;
 }