@xano/cli 0.0.20 → 0.0.22

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,45 +13,6 @@ 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
@@ -100,6 +61,45 @@ 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,12 +138,7 @@ Name: my_function
         }
         // If function_id is not provided, prompt user to select from list
         let functionId;
-        if (args.function_id) {
-            functionId = args.function_id;
-        }
-        else {
-            functionId = await this.promptForFunctionId(profile, workspaceId);
-        }
+        functionId = args.function_id ? args.function_id : (await this.promptForFunctionId(profile, workspaceId));
         // Read XanoScript content
         let xanoscript;
         if (flags.file) {
@@ -195,20 +190,20 @@ Name: my_function
         }
         // Construct the API URL
         const queryParams = new URLSearchParams({
-            publish: flags.publish ? 'true' : 'false',
             include_xanoscript: 'false',
+            publish: flags.publish ? 'true' : 'false',
         });
         const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function/${functionId}?${queryParams.toString()}`;
         // Update function via API
         try {
             const response = await fetch(apiUrl, {
-                method: 'PUT',
+                body: xanoscript,
                 headers: {
                     'accept': 'application/json',
-                    'Content-Type': 'text/x-xanoscript',
                     'Authorization': `Bearer ${profile.access_token}`,
+                    'Content-Type': 'text/x-xanoscript',
                 },
-                body: xanoscript,
+                method: 'PUT',
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -239,41 +234,54 @@ Name: my_function
             }
         }
     }
-    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, {
-                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}`);
-            }
-            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)}`);
-                }
-            }
-            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}`);
+        }
+        // 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) {
+            // Clean up temp file
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            this.error(`Editor exited with an error: ${error}`);
+        }
+        return tmpFile;
     }
     async editFunctionContent(xanoscript) {
         // Get the EDITOR environment variable
@@ -327,70 +335,60 @@ Name: my_function
             throw new Error(`Failed to read edited file: ${error}`);
         }
     }
-    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;
+    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 {
-            originalContent = fs.readFileSync(filePath, 'utf8');
+            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 '';
         }
         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');
+            throw error;
         }
-        catch (error) {
-            this.error(`Failed to create temporary file: ${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'`);
         }
-        // Open the editor
+        // Read credentials file
         try {
-            execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
+            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) {
-            // Clean up temp file
-            try {
-                fs.unlinkSync(tmpFile);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-            this.error(`Editor exited with an error: ${error}`);
+            this.error(`Failed to parse credentials file: ${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 {
@@ -398,18 +396,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();
@@ -441,10 +439,10 @@ Name: my_function
             // Prompt user to select a function
             const answer = await inquirer.prompt([
                 {
-                    type: 'list',
-                    name: 'functionId',
-                    message: 'Select a function to edit:',
                     choices,
+                    message: 'Select a function to edit:',
+                    name: 'functionId',
+                    type: 'list',
                 },
             ]);
             return answer.functionId;
@@ -458,25 +456,20 @@ Name: my_function
             }
         }
     }
-    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 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();
+        });
     }
 }

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

@@ -3,17 +3,17 @@ 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 promptForFunctionId;
     private loadCredentials;
+    private promptForFunctionId;
 }

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,31 +12,6 @@ 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
@@ -76,6 +51,31 @@ 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,12 +110,7 @@ function yo {
         }
         // If function_id is not provided, prompt user to select from list
         let functionId;
-        if (args.function_id) {
-            functionId = args.function_id;
-        }
-        else {
-            functionId = await this.promptForFunctionId(profile, workspaceId);
-        }
+        functionId = args.function_id ? args.function_id : (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;
@@ -128,11 +123,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();
@@ -189,24 +184,45 @@ 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();
@@ -238,10 +254,10 @@ function yo {
             // Prompt user to select a function
             const answer = await inquirer.prompt([
                 {
-                    type: 'list',
-                    name: 'functionId',
-                    message: 'Select a function:',
                     choices,
+                    message: 'Select a function:',
+                    name: 'functionId',
+                    type: 'list',
                 },
             ]);
             return answer.functionId;
@@ -255,25 +271,4 @@ 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,20 @@
 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>;
-        order: 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;
 }