@xano/cli 0.0.24 → 0.0.26

package/dist/commands/function/edit/index.js

@@ -1,10 +1,10 @@
 import { Args, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
-import * as yaml from 'js-yaml';
 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 * as yaml from 'js-yaml';
+import inquirer from 'inquirer';
 import BaseCommand from '../../../base-command.js';
 export default class FunctionEdit extends BaseCommand {
     static args = {
@@ -13,6 +13,45 @@ export default class FunctionEdit extends BaseCommand {
             required: false,
         }),
     };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (optional if set in profile)',
+            required: false,
+        }),
+        file: Flags.string({
+            char: 'f',
+            description: 'Path 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 updating function (requires --file)',
+            required: false,
+            default: false,
+        }),
+        publish: Flags.boolean({
+            description: 'Publish the function after editing',
+            required: false,
+            default: true,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+    };
     static description = 'Edit a function in a workspace';
     static examples = [
         `$ xano function:edit 163
@@ -61,45 +100,6 @@ Name: my_function
 }
 `,
     ];
-    static flags = {
-        ...BaseCommand.baseFlags,
-        edit: Flags.boolean({
-            char: 'e',
-            default: false,
-            description: 'Open file in editor before updating function (requires --file)',
-            required: false,
-        }),
-        file: Flags.string({
-            char: 'f',
-            description: 'Path to file containing XanoScript code',
-            exclusive: ['stdin'],
-            required: false,
-        }),
-        output: Flags.string({
-            char: 'o',
-            default: 'summary',
-            description: 'Output format',
-            options: ['summary', 'json'],
-            required: false,
-        }),
-        publish: Flags.boolean({
-            default: true,
-            description: 'Publish the function after editing',
-            required: false,
-        }),
-        stdin: Flags.boolean({
-            char: 's',
-            default: false,
-            description: 'Read XanoScript code from stdin',
-            exclusive: ['file'],
-            required: false,
-        }),
-        workspace: Flags.string({
-            char: 'w',
-            description: 'Workspace ID (optional if set in profile)',
-            required: false,
-        }),
-    };
     async run() {
         const { args, flags } = await this.parse(FunctionEdit);
         // Get profile name (default or from flag/env)
@@ -138,7 +138,12 @@ Name: my_function
         }
         // If function_id is not provided, prompt user to select from list
         let functionId;
-        functionId = args.function_id ? args.function_id : (await this.promptForFunctionId(profile, workspaceId));
+        if (args.function_id) {
+            functionId = args.function_id;
+        }
+        else {
+            functionId = await this.promptForFunctionId(profile, workspaceId);
+        }
         // Read XanoScript content
         let xanoscript;
         if (flags.file) {
@@ -190,20 +195,20 @@ Name: my_function
         }
         // Construct the API URL
         const queryParams = new URLSearchParams({
-            include_xanoscript: 'false',
             publish: flags.publish ? 'true' : 'false',
+            include_xanoscript: 'false',
         });
         const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function/${functionId}?${queryParams.toString()}`;
         // Update function via API
         try {
             const response = await fetch(apiUrl, {
-                body: xanoscript,
+                method: 'PUT',
                 headers: {
                     'accept': 'application/json',
-                    'Authorization': `Bearer ${profile.access_token}`,
                     'Content-Type': 'text/x-xanoscript',
+                    'Authorization': `Bearer ${profile.access_token}`,
                 },
-                method: 'PUT',
+                body: xanoscript,
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -234,54 +239,41 @@ Name: my_function
             }
         }
     }
-    async editFile(filePath) {
-        // Get the EDITOR environment variable
-        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
+    async fetchFunctionCode(profile, workspaceId, functionId) {
+        const queryParams = new URLSearchParams({
+            include_xanoscript: 'true',
+        });
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function/${functionId}?${queryParams.toString()}`;
         try {
-            execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
-        }
-        catch (error) {
-            // Clean up temp file
-            try {
-                fs.unlinkSync(tmpFile);
+            const response = await fetch(apiUrl, {
+                method: 'GET',
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
             }
-            catch {
-                // Ignore cleanup errors
+            const result = await response.json();
+            // Handle xanoscript as an object with status and value
+            if (result.xanoscript) {
+                if (result.xanoscript.status === 'ok' && result.xanoscript.value !== undefined) {
+                    return result.xanoscript.value;
+                }
+                else if (typeof result.xanoscript === 'string') {
+                    return result.xanoscript;
+                }
+                else {
+                    throw new Error(`Invalid xanoscript format: ${JSON.stringify(result.xanoscript)}`);
+                }
             }
-            this.error(`Editor exited with an error: ${error}`);
+            return '';
+        }
+        catch (error) {
+            throw error;
         }
-        return tmpFile;
     }
     async editFunctionContent(xanoscript) {
         // Get the EDITOR environment variable
@@ -335,60 +327,70 @@ Name: my_function
             throw new Error(`Failed to read edited file: ${error}`);
         }
     }
-    async fetchFunctionCode(profile, workspaceId, functionId) {
-        const queryParams = new URLSearchParams({
-            include_xanoscript: 'true',
-        });
-        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function/${functionId}?${queryParams.toString()}`;
+    async editFile(filePath) {
+        // Get the EDITOR environment variable
+        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 {
-            const response = await fetch(apiUrl, {
-                headers: {
-                    'accept': 'application/json',
-                    'Authorization': `Bearer ${profile.access_token}`,
-                },
-                method: 'GET',
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
-            }
-            const result = await response.json();
-            // Handle xanoscript as an object with status and value
-            if (result.xanoscript) {
-                if (result.xanoscript.status === 'ok' && result.xanoscript.value !== undefined) {
-                    return result.xanoscript.value;
-                }
-                if (typeof result.xanoscript === 'string') {
-                    return result.xanoscript;
-                }
-                throw new Error(`Invalid xanoscript format: ${JSON.stringify(result.xanoscript)}`);
-            }
-            return '';
+            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) {
-            throw error;
+            this.error(`Failed to read file '${filePath}': ${error}`);
         }
-    }
-    loadCredentials() {
-        const configDir = path.join(os.homedir(), '.xano');
-        const credentialsPath = path.join(configDir, 'credentials.yaml');
-        // Check if credentials file exists
-        if (!fs.existsSync(credentialsPath)) {
-            this.error(`Credentials file not found at ${credentialsPath}\n` +
-                `Create a profile using 'xano profile:create'`);
+        // 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');
         }
-        // Read credentials file
+        catch (error) {
+            this.error(`Failed to create temporary file: ${error}`);
+        }
+        // Open the editor
         try {
-            const fileContent = fs.readFileSync(credentialsPath, 'utf8');
-            const parsed = yaml.load(fileContent);
-            if (!parsed || typeof parsed !== 'object' || !('profiles' in parsed)) {
-                this.error('Credentials file has invalid format.');
-            }
-            return parsed;
+            execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
         }
         catch (error) {
-            this.error(`Failed to parse credentials file: ${error}`);
+            // Clean up temp file
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            this.error(`Editor exited with an error: ${error}`);
         }
+        return tmpFile;
+    }
+    async readStdin() {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            process.stdin.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            process.stdin.on('end', () => {
+                resolve(Buffer.concat(chunks).toString('utf8'));
+            });
+            process.stdin.on('error', (error) => {
+                reject(error);
+            });
+            // Resume stdin if it was paused
+            process.stdin.resume();
+        });
     }
     async promptForFunctionId(profile, workspaceId) {
         try {
@@ -396,18 +398,18 @@ Name: my_function
             const queryParams = new URLSearchParams({
                 include_draft: 'false',
                 include_xanoscript: 'false',
-                order: 'desc',
                 page: '1',
                 per_page: '50',
                 sort: 'created_at',
+                order: 'desc',
             });
             const listUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function?${queryParams.toString()}`;
             const response = await fetch(listUrl, {
+                method: 'GET',
                 headers: {
                     'accept': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,
                 },
-                method: 'GET',
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -439,10 +441,10 @@ Name: my_function
             // Prompt user to select a function
             const answer = await inquirer.prompt([
                 {
-                    choices,
-                    message: 'Select a function to edit:',
-                    name: 'functionId',
                     type: 'list',
+                    name: 'functionId',
+                    message: 'Select a function to edit:',
+                    choices,
                 },
             ]);
             return answer.functionId;
@@ -456,20 +458,25 @@ Name: my_function
             }
         }
     }
-    async readStdin() {
-        return new Promise((resolve, reject) => {
-            const chunks = [];
-            process.stdin.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            process.stdin.on('end', () => {
-                resolve(Buffer.concat(chunks).toString('utf8'));
-            });
-            process.stdin.on('error', (error) => {
-                reject(error);
-            });
-            // Resume stdin if it was paused
-            process.stdin.resume();
-        });
+    loadCredentials() {
+        const configDir = path.join(os.homedir(), '.xano');
+        const credentialsPath = path.join(configDir, 'credentials.yaml');
+        // Check if credentials file exists
+        if (!fs.existsSync(credentialsPath)) {
+            this.error(`Credentials file not found at ${credentialsPath}\n` +
+                `Create a profile using 'xano profile:create'`);
+        }
+        // Read credentials file
+        try {
+            const fileContent = fs.readFileSync(credentialsPath, 'utf8');
+            const parsed = yaml.load(fileContent);
+            if (!parsed || typeof parsed !== 'object' || !('profiles' in parsed)) {
+                this.error('Credentials file has invalid format.');
+            }
+            return parsed;
+        }
+        catch (error) {
+            this.error(`Failed to parse credentials file: ${error}`);
+        }
     }
 }

package/dist/commands/function/get/index.d.ts

@@ -3,17 +3,16 @@ export default class FunctionGet extends BaseCommand {
     static args: {
         function_id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
-    static description: string;
-    static examples: string[];
     static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         include_draft: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         include_xanoscript: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        workspace: 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>;
-    private loadCredentials;
     private promptForFunctionId;
+    private loadCredentials;
 }

package/dist/commands/function/get/index.js

@@ -1,9 +1,9 @@
 import { Args, 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 BaseCommand from '../../../base-command.js';
 export default class FunctionGet extends BaseCommand {
     static args = {
@@ -12,6 +12,31 @@ export default class FunctionGet extends BaseCommand {
             required: false,
         }),
     };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (optional if set in profile)',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json', 'xs'],
+        }),
+        include_draft: Flags.boolean({
+            description: 'Include draft version',
+            required: false,
+            default: false,
+        }),
+        include_xanoscript: Flags.boolean({
+            description: 'Include XanoScript in response',
+            required: false,
+            default: false,
+        }),
+    };
     static description = 'Get a specific function from a workspace';
     static examples = [
         `$ xano function:get 145 -w 40
@@ -51,31 +76,6 @@ function yo {
 }
 `,
     ];
-    static flags = {
-        ...BaseCommand.baseFlags,
-        include_draft: Flags.boolean({
-            default: false,
-            description: 'Include draft version',
-            required: false,
-        }),
-        include_xanoscript: Flags.boolean({
-            default: false,
-            description: 'Include XanoScript in response',
-            required: false,
-        }),
-        output: Flags.string({
-            char: 'o',
-            default: 'summary',
-            description: 'Output format',
-            options: ['summary', 'json', 'xs'],
-            required: false,
-        }),
-        workspace: Flags.string({
-            char: 'w',
-            description: 'Workspace ID (optional if set in profile)',
-            required: false,
-        }),
-    };
     async run() {
         const { args, flags } = await this.parse(FunctionGet);
         // Get profile name (default or from flag/env)
@@ -110,7 +110,12 @@ function yo {
         }
         // If function_id is not provided, prompt user to select from list
         let functionId;
-        functionId = args.function_id ? args.function_id : (await this.promptForFunctionId(profile, workspaceId));
+        if (args.function_id) {
+            functionId = args.function_id;
+        }
+        else {
+            functionId = await this.promptForFunctionId(profile, workspaceId);
+        }
         // Build query parameters
         // Automatically set include_xanoscript to true if output format is xs
         const includeXanoscript = flags.output === 'xs' ? true : flags.include_xanoscript;
@@ -123,11 +128,11 @@ function yo {
         // Fetch function 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();
@@ -184,45 +189,24 @@ function yo {
             }
         }
     }
-    loadCredentials() {
-        const configDir = path.join(os.homedir(), '.xano');
-        const credentialsPath = path.join(configDir, 'credentials.yaml');
-        // Check if credentials file exists
-        if (!fs.existsSync(credentialsPath)) {
-            this.error(`Credentials file not found at ${credentialsPath}\n` +
-                `Create a profile using 'xano profile:create'`);
-        }
-        // Read credentials file
-        try {
-            const fileContent = fs.readFileSync(credentialsPath, 'utf8');
-            const parsed = yaml.load(fileContent);
-            if (!parsed || typeof parsed !== 'object' || !('profiles' in parsed)) {
-                this.error('Credentials file has invalid format.');
-            }
-            return parsed;
-        }
-        catch (error) {
-            this.error(`Failed to parse credentials file: ${error}`);
-        }
-    }
     async promptForFunctionId(profile, workspaceId) {
         try {
             // Fetch list of functions
             const queryParams = new URLSearchParams({
                 include_draft: 'false',
                 include_xanoscript: 'false',
-                order: 'desc',
                 page: '1',
                 per_page: '50',
                 sort: 'created_at',
+                order: 'desc',
             });
             const listUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function?${queryParams.toString()}`;
             const response = await fetch(listUrl, {
+                method: 'GET',
                 headers: {
                     'accept': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,
                 },
-                method: 'GET',
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -254,10 +238,10 @@ function yo {
             // Prompt user to select a function
             const answer = await inquirer.prompt([
                 {
-                    choices,
-                    message: 'Select a function:',
-                    name: 'functionId',
                     type: 'list',
+                    name: 'functionId',
+                    message: 'Select a function:',
+                    choices,
                 },
             ]);
             return answer.functionId;
@@ -271,4 +255,25 @@ function yo {
             }
         }
     }
+    loadCredentials() {
+        const configDir = path.join(os.homedir(), '.xano');
+        const credentialsPath = path.join(configDir, 'credentials.yaml');
+        // Check if credentials file exists
+        if (!fs.existsSync(credentialsPath)) {
+            this.error(`Credentials file not found at ${credentialsPath}\n` +
+                `Create a profile using 'xano profile:create'`);
+        }
+        // Read credentials file
+        try {
+            const fileContent = fs.readFileSync(credentialsPath, 'utf8');
+            const parsed = yaml.load(fileContent);
+            if (!parsed || typeof parsed !== 'object' || !('profiles' in parsed)) {
+                this.error('Credentials file has invalid format.');
+            }
+            return parsed;
+        }
+        catch (error) {
+            this.error(`Failed to parse credentials file: ${error}`);
+        }
+    }
 }

package/dist/commands/function/list/index.d.ts

@@ -1,20 +1,19 @@
 import BaseCommand from '../../../base-command.js';
 export default class FunctionList extends BaseCommand {
     static args: {};
-    static description: string;
-    static examples: string[];
     static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         include_draft: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         include_xanoscript: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        order: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         page: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         per_page: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         sort: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        order: 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 loadCredentials;
 }