@xano/cli 0.0.26 → 0.0.27

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

@@ -0,0 +1,136 @@
+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 BaseCommand from '../../../base-command.js';
+export default class WorkspaceGet extends BaseCommand {
+    static args = {
+        workspace_id: Args.integer({
+            description: 'Workspace ID to get details for (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    static description = 'Get details of a specific workspace from the Xano Metadata API';
+    static examples = [
+        `$ xano workspace get 123
+Workspace: my-workspace (ID: 123)
+  Description: My workspace description
+  Created: 2024-01-15
+`,
+        `$ xano workspace get --output json
+{
+  "id": 123,
+  "name": "my-workspace",
+  "description": "My workspace description"
+}
+`,
+        `$ xano workspace get 456 -p production -o json
+{
+  "id": 456,
+  "name": "production-workspace"
+}
+`,
+    ];
+    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)
+        const profileName = flags.profile || this.getDefaultProfile();
+        // Load credentials
+        const credentials = this.loadCredentials();
+        // Get the profile configuration
+        if (!(profileName in credentials.profiles)) {
+            this.error(`Profile '${profileName}' not found. Available profiles: ${Object.keys(credentials.profiles).join(', ')}\n` +
+                `Create a profile using 'xano profile create'`);
+        }
+        const profile = credentials.profiles[profileName];
+        // Validate required fields
+        if (!profile.instance_origin) {
+            this.error(`Profile '${profileName}' is missing instance_origin`);
+        }
+        if (!profile.access_token) {
+            this.error(`Profile '${profileName}' is missing access_token`);
+        }
+        // Get workspace ID from args or profile
+        const workspaceId = args.workspace_id || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Either pass a workspace ID as an argument or set one in your profile.\n' +
+                'Usage: xano workspace get <workspace_id>');
+        }
+        // Construct the API URL
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}`;
+        // Fetch workspace from the API
+        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();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            const workspace = await response.json();
+            // Output results
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(workspace, null, 2));
+            }
+            else {
+                // summary format
+                this.log(`Workspace: ${workspace.name} (ID: ${workspace.id})`);
+                if (workspace.description) {
+                    this.log(`  Description: ${workspace.description}`);
+                }
+                if (workspace.created_at) {
+                    const createdDate = new Date(workspace.created_at * 1000).toISOString().split('T')[0];
+                    this.log(`  Created: ${createdDate}`);
+                }
+                if (workspace.updated_at) {
+                    const updatedDate = new Date(workspace.updated_at * 1000).toISOString().split('T')[0];
+                    this.log(`  Updated: ${updatedDate}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to fetch workspace: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to fetch workspace: ${String(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'`);
+        }
+        // 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/workspace/list/index.d.ts

@@ -1,11 +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,15 +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
@@ -24,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,9 @@
 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 snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
 export default class Pull extends BaseCommand {
     static args = {
@@ -11,24 +12,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 +24,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)
@@ -79,16 +80,16 @@ Pulled 58 documents to ./backup
             records: flags.records.toString(),
         });
         // Construct the API URL
-        const apiUrl = `${profile.instance_origin}/api:meta/beta/workspace/${workspaceId}/multidoc?${queryParams.toString()}`;
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/multidoc?${queryParams.toString()}`;
         // Fetch multidoc from the API
         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();
@@ -130,35 +131,101 @@ Pulled 58 documents to ./backup
         const filenameCounters = new Map();
         let writtenCount = 0;
         for (const doc of documents) {
-            // Create the type subdirectory
-            const typeDir = path.join(outputDir, doc.type);
-            fs.mkdirSync(typeDir, { recursive: true });
-            // Build the base filename
-            let baseName = this.sanitizeFilename(doc.name);
-            if (doc.verb) {
-                baseName = `${baseName}_${doc.verb}`;
+            let typeDir;
+            let baseName;
+            if (doc.type === 'workspace') {
+                // workspace → workspace/{name}.xs
+                typeDir = path.join(outputDir, 'workspace');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'workspace_trigger') {
+                // workspace_trigger → workspace/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent_trigger') {
+                // agent_trigger → agent/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'agent', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server_trigger') {
+                // mcp_server_trigger → mcp_server/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'mcp_server', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'table_trigger') {
+                // table_trigger → table/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'table', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'api_group') {
+                // api_group "test" → api/test/api_group.xs
+                const groupFolder = snakeCase(doc.name);
+                typeDir = path.join(outputDir, 'api', groupFolder);
+                baseName = 'api_group';
+            }
+            else if (doc.type === 'query' && doc.apiGroup) {
+                // query in group "test" → api/test/{query_name}.xs
+                const groupFolder = snakeCase(doc.apiGroup);
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, 'api', groupFolder, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
+            else {
+                // Default: split folder path from name
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, doc.type, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
             }
-            // Track duplicates per type directory
-            if (!filenameCounters.has(doc.type)) {
-                filenameCounters.set(doc.type, new Map());
+            fs.mkdirSync(typeDir, { recursive: true });
+            // Track duplicates per directory
+            const dirKey = path.relative(outputDir, typeDir);
+            if (!filenameCounters.has(dirKey)) {
+                filenameCounters.set(dirKey, new Map());
             }
-            const typeCounters = filenameCounters.get(doc.type);
+            const typeCounters = filenameCounters.get(dirKey);
             const count = typeCounters.get(baseName) || 0;
             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 +268,13 @@ Pulled 58 documents to ./backup
         if (verbMatch) {
             verb = verbMatch[1];
         }
-        return { type, name, verb, content };
+        // Extract api_group if present (e.g., api_group = "test")
+        let apiGroup;
+        const apiGroupMatch = content.match(/api_group\s*=\s*"([^"]*)"/);
+        if (apiGroupMatch) {
+            apiGroup = apiGroupMatch[1];
+        }
+        return { apiGroup, content, name, type, verb };
     }
     /**
      * Sanitize a document name for use as a filename.
@@ -209,30 +282,6 @@ Pulled 58 documents to ./backup
      * characters that are unsafe in filenames.
      */
     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}`);
-        }
+        return snakeCase(name.replaceAll('"', ''));
     }
 }

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

@@ -8,6 +8,7 @@ export default class Push extends BaseCommand {
     static flags: {
         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>;
     };
     run(): Promise<void>;
     /**

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 = {
@@ -89,17 +89,17 @@ Pushed 58 documents from ./backup
         }
         const multidoc = documents.join('\n---\n');
         // Construct the API URL
-        const apiUrl = `${profile.instance_origin}/api:meta/beta/workspace/${workspaceId}/multidoc`;
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/multidoc`;
         // 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();
@@ -107,7 +107,7 @@ Pushed 58 documents from ./backup
             }
             // Log the response if any
             const responseText = await response.text();
-            if (responseText) {
+            if (responseText && responseText !== 'null') {
                 this.log(responseText);
             }
         }

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;
@@ -25,11 +25,11 @@ export default abstract class BaseRunCommand extends BaseCommand {
     /**
      * Initialize the run command with profile and HTTP client
      */
-    protected initRunCommand(profileFlag?: string): Promise<void>;
+    protected initRunCommand(profileFlag?: string, verbose?: boolean): Promise<void>;
     /**
      * Initialize with project required
      */
-    protected initRunCommandWithProject(profileFlag?: string): Promise<void>;
+    protected initRunCommandWithProject(profileFlag?: string, verbose?: boolean): Promise<void>;
     /**
      * Load credentials from file
      */

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 {
@@ -14,7 +14,7 @@ export default class BaseRunCommand extends BaseCommand {
     /**
      * Initialize the run command with profile and HTTP client
      */
-    async initRunCommand(profileFlag) {
+    async initRunCommand(profileFlag, verbose) {
         this.profileName = profileFlag || this.getDefaultProfile();
         const credentials = this.loadCredentials();
         if (!(this.profileName in credentials.profiles)) {
@@ -27,19 +27,21 @@ 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,
         });
     }
     /**
      * Initialize with project required
      */
-    async initRunCommandWithProject(profileFlag) {
-        await this.initRunCommand(profileFlag);
+    async initRunCommandWithProject(profileFlag, verbose) {
+        await this.initRunCommand(profileFlag, verbose);
         if (!this.profile.project) {
             this.error(`Profile '${this.profileName}' is missing project. ` +
-                `Update your profile with 'xano profile:edit --project <project-id>'`);
+                `Run 'xano profile:wizard' to set up your profile or use 'xano profile:edit --project <project-id>'`);
         }
     }
     /**