@xano/cli 0.0.21 → 0.0.22

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

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
+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 BaseCommand from '../../../base-command.js';
 export default class WorkspaceEdit extends BaseCommand {
     static args = {
@@ -11,36 +11,6 @@ export default class WorkspaceEdit extends BaseCommand {
             required: false,
         }),
     };
-    static flags = {
-        ...BaseCommand.baseFlags,
-        name: Flags.string({
-            char: 'n',
-            description: 'New name for the workspace',
-            required: false,
-        }),
-        description: Flags.string({
-            char: 'd',
-            description: 'New description for the workspace',
-            required: false,
-        }),
-        swagger: Flags.boolean({
-            description: 'Enable or disable swagger documentation',
-            required: false,
-            allowNo: true,
-        }),
-        'require-token': Flags.boolean({
-            description: 'Whether to require a token for documentation access',
-            required: false,
-            allowNo: true,
-        }),
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-    };
     static description = 'Edit an existing workspace via the Xano Metadata API';
     static examples = [
         `$ xano workspace edit 123 --name "new-name"
@@ -63,6 +33,36 @@ Updated workspace: my-workspace (ID: 123)
 }
 `,
     ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        description: Flags.string({
+            char: 'd',
+            description: 'New description for the workspace',
+            required: false,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'New name for the workspace',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        'require-token': Flags.boolean({
+            allowNo: true,
+            description: 'Whether to require a token for documentation access',
+            required: false,
+        }),
+        swagger: Flags.boolean({
+            allowNo: true,
+            description: 'Enable or disable swagger documentation',
+            required: false,
+        }),
+    };
     async run() {
         const { args, flags } = await this.parse(WorkspaceEdit);
         // Get profile name (default or from flag/env)
@@ -112,13 +112,13 @@ Updated workspace: my-workspace (ID: 123)
         // Update workspace via the API
         try {
             const response = await fetch(apiUrl, {
-                method: 'PUT',
+                body: JSON.stringify(body),
                 headers: {
                     'accept': 'application/json',
-                    'content-type': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,
+                    'content-type': 'application/json',
                 },
-                body: JSON.stringify(body),
+                method: 'PUT',
             });
             if (!response.ok) {
                 const errorText = await response.text();

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

@@ -6,13 +6,13 @@ export default class WorkspaceGet extends BaseCommand {
             min?: number;
         }>;
     };
+    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>;
     private loadCredentials;
 }

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

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
+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 BaseCommand from '../../../base-command.js';
 export default class WorkspaceGet extends BaseCommand {
     static args = {
@@ -11,16 +11,6 @@ export default class WorkspaceGet extends BaseCommand {
             required: false,
         }),
     };
-    static flags = {
-        ...BaseCommand.baseFlags,
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-    };
     static description = 'Get details of a specific workspace from the Xano Metadata API';
     static examples = [
         `$ xano workspace get 123
@@ -42,6 +32,16 @@ Workspace: my-workspace (ID: 123)
 }
 `,
     ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+    };
     async run() {
         const { args, flags } = await this.parse(WorkspaceGet);
         // Get profile name (default or from flag/env)
@@ -72,11 +72,11 @@ Workspace: my-workspace (ID: 123)
         // Fetch workspace 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();

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

@@ -1,12 +1,12 @@
 import BaseCommand from '../../../base-command.js';
 export default class WorkspaceList extends BaseCommand {
+    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>;
     private loadCredentials;
 }

package/dist/commands/workspace/list/index.js

@@ -1,20 +1,10 @@
 import { Flags } from '@oclif/core';
+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 BaseCommand from '../../../base-command.js';
 export default class WorkspaceList extends BaseCommand {
-    static flags = {
-        ...BaseCommand.baseFlags,
-        output: Flags.string({
-            char: 'o',
-            description: 'Output format',
-            required: false,
-            default: 'summary',
-            options: ['summary', 'json'],
-        }),
-    };
     static description = 'List all workspaces from the Xano Metadata API';
     static examples = [
         `$ xano workspace:list
@@ -53,6 +43,16 @@ Available workspaces:
 }
 `,
     ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+    };
     async run() {
         const { flags } = await this.parse(WorkspaceList);
         // Get profile name (default or from flag/env)
@@ -77,11 +77,11 @@ Available workspaces:
         // Fetch workspaces 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();
@@ -111,11 +111,11 @@ Available workspaces:
                 else {
                     this.log('Available workspaces:');
                     for (const workspace of workspaces) {
-                        if (workspace.id !== undefined) {
-                            this.log(`  - ${workspace.name} (ID: ${workspace.id})`);
+                        if (workspace.id === undefined) {
+                            this.log(`  - ${workspace.name}`);
                         }
                         else {
-                            this.log(`  - ${workspace.name}`);
+                            this.log(`  - ${workspace.name} (ID: ${workspace.id})`);
                         }
                     }
                 }

package/dist/commands/workspace/pull/index.d.ts

@@ -3,16 +3,17 @@ export default class Pull extends BaseCommand {
     static args: {
         directory: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
+    static examples: string[];
     static flags: {
-        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         env: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         records: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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;
     /**
      * Parse a single document to extract its type, name, and optional verb.
      * Skips leading comment lines (starting with //) to find the first
@@ -25,5 +26,4 @@ export default class Pull extends BaseCommand {
      * characters that are unsafe in filenames.
      */
     private sanitizeFilename;
-    private loadCredentials;
 }

package/dist/commands/workspace/pull/index.js

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
+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 BaseCommand from '../../../base-command.js';
 export default class Pull extends BaseCommand {
     static args = {
@@ -11,24 +11,6 @@ export default class Pull extends BaseCommand {
             required: true,
         }),
     };
-    static flags = {
-        ...BaseCommand.baseFlags,
-        workspace: Flags.string({
-            char: 'w',
-            description: 'Workspace ID (optional if set in profile)',
-            required: false,
-        }),
-        env: Flags.boolean({
-            description: 'Include environment variables',
-            required: false,
-            default: false,
-        }),
-        records: Flags.boolean({
-            description: 'Include records',
-            required: false,
-            default: false,
-        }),
-    };
     static description = 'Pull a workspace multidoc from the Xano Metadata API and split into individual files';
     static examples = [
         `$ xano workspace pull ./my-workspace
@@ -41,6 +23,24 @@ Pulled 15 documents to ./output
 Pulled 58 documents to ./backup
 `,
     ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        env: Flags.boolean({
+            default: false,
+            description: 'Include environment variables',
+            required: false,
+        }),
+        records: Flags.boolean({
+            default: false,
+            description: 'Include records',
+            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(Pull);
         // Get profile name (default or from flag/env)
@@ -84,11 +84,11 @@ Pulled 58 documents to ./backup
         let responseText;
         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();
@@ -147,18 +147,34 @@ Pulled 58 documents to ./backup
             typeCounters.set(baseName, count + 1);
             // Append numeric suffix for duplicates
             let filename;
-            if (count === 0) {
-                filename = `${baseName}.xs`;
-            }
-            else {
-                filename = `${baseName}_${count + 1}.xs`;
-            }
+            filename = count === 0 ? `${baseName}.xs` : `${baseName}_${count + 1}.xs`;
             const filePath = path.join(typeDir, filename);
             fs.writeFileSync(filePath, doc.content, 'utf8');
             writtenCount++;
         }
         this.log(`Pulled ${writtenCount} documents to ${args.directory}`);
     }
+    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}`);
+        }
+    }
     /**
      * Parse a single document to extract its type, name, and optional verb.
      * Skips leading comment lines (starting with //) to find the first
@@ -201,7 +217,7 @@ Pulled 58 documents to ./backup
         if (verbMatch) {
             verb = verbMatch[1];
         }
-        return { type, name, verb, content };
+        return { content, name, type, verb };
     }
     /**
      * Sanitize a document name for use as a filename.
@@ -210,29 +226,8 @@ Pulled 58 documents to ./backup
      */
     sanitizeFilename(name) {
         return name
-            .replace(/"/g, '')
-            .replace(/\s+/g, '_')
-            .replace(/[<>:"/\\|?*]/g, '_');
-    }
-    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}`);
-        }
+            .replaceAll('"', '')
+            .replaceAll(/\s+/g, '_')
+            .replaceAll(/[<>:"/\\|?*]/g, '_');
     }
 }

package/dist/commands/workspace/push/index.js

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
+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 BaseCommand from '../../../base-command.js';
 export default class Push extends BaseCommand {
     static args = {
@@ -93,13 +93,13 @@ Pushed 58 documents from ./backup
         // POST the multidoc to the API
         try {
             const response = await fetch(apiUrl, {
-                method: 'POST',
+                body: multidoc,
                 headers: {
                     'accept': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,
                     'Content-Type': 'text/x-xanoscript',
                 },
-                body: multidoc,
+                method: 'POST',
             });
             if (!response.ok) {
                 const errorText = await response.text();

package/dist/help.d.ts

@@ -1,4 +1,4 @@
-import { Command, Help as BaseHelp } from '@oclif/core';
+import { Help as BaseHelp, Command } from '@oclif/core';
 import { CommandHelp as BaseCommandHelp } from '@oclif/core/help';
 /**
  * Custom CommandHelp class that extends the default to display environment variables

package/dist/lib/base-run-command.d.ts

@@ -4,19 +4,19 @@
 import BaseCommand from '../base-command.js';
 import { RunHttpClient } from './run-http-client.js';
 export interface ProfileConfig {
-    account_origin?: string;
-    instance_origin: string;
     access_token: string;
-    workspace?: string;
+    account_origin?: string;
     branch?: string;
+    instance_origin: string;
     project?: string;
     run_base_url?: string;
+    workspace?: string;
 }
 export interface CredentialsFile {
+    default?: string;
     profiles: {
         [key: string]: ProfileConfig;
     };
-    default?: string;
 }
 export default abstract class BaseRunCommand extends BaseCommand {
     protected httpClient: RunHttpClient;

package/dist/lib/base-run-command.js

@@ -1,10 +1,10 @@
 /**
  * Base command for all run commands
  */
+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 BaseCommand from '../base-command.js';
 import { DEFAULT_RUN_BASE_URL, RunHttpClient } from './run-http-client.js';
 export default class BaseRunCommand extends BaseCommand {
@@ -27,11 +27,11 @@ export default class BaseRunCommand extends BaseCommand {
         }
         const baseUrl = this.profile.run_base_url || DEFAULT_RUN_BASE_URL;
         this.httpClient = new RunHttpClient({
-            baseUrl,
             authToken: this.profile.access_token,
+            baseUrl,
+            logger: (msg) => this.log(msg),
             projectId: this.profile.project,
             verbose,
-            logger: (msg) => this.log(msg),
         });
     }
     /**

package/dist/lib/run-http-client.d.ts

@@ -4,47 +4,47 @@
  */
 export declare const DEFAULT_RUN_BASE_URL = "https://app.dev.xano.com/";
 export interface RunHttpClientConfig {
-    baseUrl: string;
     authToken: string;
+    baseUrl: string;
+    logger?: (message: string) => void;
     projectId?: string;
     verbose?: boolean;
-    logger?: (message: string) => void;
 }
 export declare class RunHttpClient {
     private readonly config;
     constructor(config: RunHttpClientConfig);
     /**
-     * Get the project ID
+     * Build a URL scoped to the current project
      */
-    getProjectId(): string | undefined;
+    buildProjectUrl(path: string, queryParams?: Record<string, unknown>): string;
     /**
-     * Build headers for a request
+     * Build a URL scoped to a specific session
      */
-    getHeaders(contentType?: string): HeadersInit;
+    buildSessionUrl(sessionId: string, path?: string, queryParams?: Record<string, unknown>): string;
     /**
      * Build a URL with optional query parameters
      */
     buildUrl(path: string, queryParams?: Record<string, unknown>): string;
     /**
-     * Build a URL scoped to the current project
+     * Make a DELETE request
      */
-    buildProjectUrl(path: string, queryParams?: Record<string, unknown>): string;
+    delete<T>(url: string, body?: unknown): Promise<T>;
     /**
-     * Build a URL scoped to a specific session
+     * Make a GET request
      */
-    buildSessionUrl(sessionId: string, path?: string, queryParams?: Record<string, unknown>): string;
+    get<T>(url: string): Promise<T>;
     /**
-     * Log a message if verbose mode is enabled
+     * Build headers for a request
      */
-    private log;
+    getHeaders(contentType?: string): HeadersInit;
     /**
-     * Make an HTTP request
+     * Get the project ID
      */
-    request<T>(url: string, options: RequestInit): Promise<T>;
+    getProjectId(): string | undefined;
     /**
-     * Make a GET request
+     * Make a PATCH request
      */
-    get<T>(url: string): Promise<T>;
+    patch<T>(url: string, body: unknown): Promise<T>;
     /**
      * Make a POST request with JSON body
      */
@@ -54,11 +54,11 @@ export declare class RunHttpClient {
      */
     postXanoScript<T>(url: string, code: string): Promise<T>;
     /**
-     * Make a PATCH request
+     * Make an HTTP request
      */
-    patch<T>(url: string, body: unknown): Promise<T>;
+    request<T>(url: string, options: RequestInit): Promise<T>;
     /**
-     * Make a DELETE request
+     * Log a message if verbose mode is enabled
      */
-    delete<T>(url: string, body?: unknown): Promise<T>;
+    private log;
 }