@xano/cli 0.0.20 → 0.0.22

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

@@ -2,49 +2,49 @@
  * HTTP client for Xano Run API
  * Based on @xano/run-sdk HttpClient
  */
-export declare const DEFAULT_RUN_BASE_URL = "https://app.xano.com/";
+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;
 }

package/dist/lib/run-http-client.js

@@ -2,27 +2,27 @@
  * HTTP client for Xano Run API
  * Based on @xano/run-sdk HttpClient
  */
-export const DEFAULT_RUN_BASE_URL = 'https://app.xano.com/';
+export const DEFAULT_RUN_BASE_URL = 'https://app.dev.xano.com/';
 export class RunHttpClient {
     config;
     constructor(config) {
         this.config = config;
     }
     /**
-     * Get the project ID
+     * Build a URL scoped to the current project
      */
-    getProjectId() {
-        return this.config.projectId;
+    buildProjectUrl(path, queryParams) {
+        const { projectId } = this.config;
+        if (!projectId) {
+            throw new Error('Project ID is required. Set it in your profile.');
+        }
+        return this.buildUrl(`/project/${projectId}${path}`, queryParams);
     }
     /**
-     * Build headers for a request
+     * Build a URL scoped to a specific session
      */
-    getHeaders(contentType = 'application/json') {
-        const headers = {
-            'Content-Type': contentType,
-            'Authorization': `Bearer ${this.config.authToken}`,
-        };
-        return headers;
+    buildSessionUrl(sessionId, path = '', queryParams) {
+        return this.buildUrl(`/session/${sessionId}${path}`, queryParams);
     }
     /**
      * Build a URL with optional query parameters
@@ -47,28 +47,69 @@ export class RunHttpClient {
         return url.toString();
     }
     /**
-     * Build a URL scoped to the current project
+     * Make a DELETE request
      */
-    buildProjectUrl(path, queryParams) {
-        const projectId = this.config.projectId;
-        if (!projectId) {
-            throw new Error('Project ID is required. Set it in your profile.');
-        }
-        return this.buildUrl(`/project/${projectId}${path}`, queryParams);
+    async delete(url, body) {
+        return this.request(url, {
+            body: body ? JSON.stringify(body) : undefined,
+            headers: this.getHeaders(),
+            method: 'DELETE',
+        });
     }
     /**
-     * Build a URL scoped to a specific session
+     * Make a GET request
      */
-    buildSessionUrl(sessionId, path = '', queryParams) {
-        return this.buildUrl(`/session/${sessionId}${path}`, queryParams);
+    async get(url) {
+        return this.request(url, {
+            headers: this.getHeaders(),
+            method: 'GET',
+        });
     }
     /**
-     * Log a message if verbose mode is enabled
+     * Build headers for a request
      */
-    log(message) {
-        if (this.config.verbose && this.config.logger) {
-            this.config.logger(message);
-        }
+    getHeaders(contentType = 'application/json') {
+        const headers = {
+            'Authorization': `Bearer ${this.config.authToken}`,
+            'Content-Type': contentType,
+        };
+        return headers;
+    }
+    /**
+     * Get the project ID
+     */
+    getProjectId() {
+        return this.config.projectId;
+    }
+    /**
+     * Make a PATCH request
+     */
+    async patch(url, body) {
+        return this.request(url, {
+            body: JSON.stringify(body),
+            headers: this.getHeaders(),
+            method: 'PATCH',
+        });
+    }
+    /**
+     * Make a POST request with JSON body
+     */
+    async post(url, body) {
+        return this.request(url, {
+            body: body ? JSON.stringify(body) : undefined,
+            headers: this.getHeaders(),
+            method: 'POST',
+        });
+    }
+    /**
+     * Make a POST request with XanoScript body
+     */
+    async postXanoScript(url, code) {
+        return this.request(url, {
+            body: code,
+            headers: this.getHeaders('text/x-xanoscript'),
+            method: 'POST',
+        });
     }
     /**
      * Make an HTTP request
@@ -120,52 +161,11 @@ export class RunHttpClient {
         return parsed;
     }
     /**
-     * Make a GET request
-     */
-    async get(url) {
-        return this.request(url, {
-            method: 'GET',
-            headers: this.getHeaders(),
-        });
-    }
-    /**
-     * Make a POST request with JSON body
-     */
-    async post(url, body) {
-        return this.request(url, {
-            method: 'POST',
-            headers: this.getHeaders(),
-            body: body ? JSON.stringify(body) : undefined,
-        });
-    }
-    /**
-     * Make a POST request with XanoScript body
-     */
-    async postXanoScript(url, code) {
-        return this.request(url, {
-            method: 'POST',
-            headers: this.getHeaders('text/x-xanoscript'),
-            body: code,
-        });
-    }
-    /**
-     * Make a PATCH request
-     */
-    async patch(url, body) {
-        return this.request(url, {
-            method: 'PATCH',
-            headers: this.getHeaders(),
-            body: JSON.stringify(body),
-        });
-    }
-    /**
-     * Make a DELETE request
+     * Log a message if verbose mode is enabled
      */
-    async delete(url, body) {
-        return this.request(url, {
-            method: 'DELETE',
-            headers: this.getHeaders(),
-            body: body ? JSON.stringify(body) : undefined,
-        });
+    log(message) {
+        if (this.config.verbose && this.config.logger) {
+            this.config.logger(message);
+        }
     }
 }