@xano/cli 0.0.17 → 0.0.19

package/README.md

@@ -25,7 +25,7 @@ npm install -g @xano/cli
 
 3. Execute XanoScript code:
    ```bash
-   xano run exec -f script.xs
+   xano run exec script.xs
    ```
 
 ## Commands
@@ -54,8 +54,6 @@ xano profile:set-default myprofile
 # Edit a profile
 xano profile:edit myprofile -w 123              # Set default workspace
 xano profile:edit myprofile -j my-project       # Set default project
-xano profile:edit myprofile --run-project <id>  # Set run project for xano run commands
-xano profile:edit myprofile --remove-run-project # Remove run project
 
 # Delete a profile
 xano profile:delete myprofile
@@ -100,18 +98,21 @@ Execute XanoScript code and manage projects, sessions, environment variables, an
 
 ```bash
 # Execute XanoScript (job or service)
-xano run exec -f script.xs
-xano run exec -f https://example.com/script.xs   # From URL
-xano run exec -f script.xs -a args.json          # With input arguments (file)
-xano run exec -f script.xs -a https://ex.com/args.json  # With input arguments (URL)
-xano run exec -f script.xs --edit                # Edit in $EDITOR first
-xano run exec -f script.xs --env API_KEY=secret  # With env overrides
+xano run exec script.xs                          # Single file
+xano run exec ./my-workspace                     # Directory (multidoc from .xs files)
+xano run exec https://example.com/script.xs     # From URL
+xano run exec script.xs -a args.json             # With input arguments (file)
+xano run exec script.xs -a https://ex.com/args.json  # With input arguments (URL)
+xano run exec script.xs --edit                   # Edit in $EDITOR first
+xano run exec script.xs --env API_KEY=secret     # With env overrides
 cat script.xs | xano run exec --stdin            # From stdin
 
 # Get document info (type, inputs, env vars)
 xano run info -f script.xs
 ```
 
+When a directory is provided, all `.xs` files are collected recursively and combined into a multidoc (joined with `---` separators), similar to `xano workspace push`.
+
 #### Projects
 
 ```bash
@@ -225,7 +226,7 @@ profiles:
     access_token: <token>
     workspace: <workspace_id>
     branch: <branch_id>
-    run_project: <run_project_id>  # Used by xano run commands
+    project: <project_id>
 default: default
 ```
 

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

@@ -1,6 +1,8 @@
 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 flags: {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
@@ -13,6 +15,14 @@ export default class RunExec extends BaseRunCommand {
     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;

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

@@ -1,16 +1,21 @@
-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 args = {
+        path: Args.string({
+            description: 'Path to file or directory containing XanoScript code (directory creates multidoc from .xs files)',
+            required: false,
+        }),
+    };
     static flags = {
         ...BaseRunCommand.baseFlags,
         file: Flags.string({
             char: 'f',
-            description: 'Path or URL to file containing XanoScript code',
+            description: 'Path or URL to file containing XanoScript code (deprecated: use path argument instead)',
             required: false,
             exclusive: ['stdin'],
         }),
@@ -23,10 +28,9 @@ export default class RunExec extends BaseRunCommand {
         }),
         edit: Flags.boolean({
             char: 'e',
-            description: 'Open file in editor before running (requires --file)',
+            description: 'Open file in editor before running (requires path argument or --file)',
             required: false,
             default: false,
-            dependsOn: ['file'],
         }),
         output: Flags.string({
             char: 'o',
@@ -48,11 +52,16 @@ export default class RunExec extends BaseRunCommand {
     };
     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 +70,63 @@ 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!
 ...
 `,
     ];
     async run() {
-        const { flags } = await this.parse(RunExec);
+        const { args, flags } = await this.parse(RunExec);
         // Initialize with project required
         await this.initRunCommandWithProject(flags.profile);
+        // 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) {
@@ -202,6 +229,48 @@ Executed successfully!
             }
         }
     }
+    /**
+     * 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');
+    }
+    /**
+     * 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('');