@xano/cli 0.0.15 → 0.0.17

package/README.md

@@ -35,7 +35,7 @@ npm install -g @xano/cli
 Profiles store your Xano credentials and default workspace/project settings.
 
 ```bash
-# Create a profile interactively
+# Create a profile interactively (auto-fetches run projects)
 xano profile:wizard
 
 # Create a profile manually
@@ -52,13 +52,17 @@ xano profile:list --details
 xano profile:set-default myprofile
 
 # Edit a profile
-xano profile:edit myprofile -w 123        # Set default workspace
-xano profile:edit myprofile -j my-project # Set default project
+xano profile:edit myprofile -w 123              # Set default workspace
+xano profile:edit myprofile -j my-project       # Set default project
+xano profile:edit myprofile --run-project <id>  # Set run project for xano run commands
+xano profile:edit myprofile --remove-run-project # Remove run project
 
 # Delete a profile
 xano profile:delete myprofile
 ```
 
+The `profile:wizard` command automatically fetches your run projects and sets the first one as the default for `xano run` commands.
+
 ### Workspaces
 
 ```bash
@@ -211,7 +215,19 @@ All commands support these options:
 
 ## Configuration
 
-Profiles are stored in `~/.xano/credentials.yaml`.
+Profiles are stored in `~/.xano/credentials.yaml`:
+
+```yaml
+profiles:
+  default:
+    account_origin: https://app.xano.com
+    instance_origin: https://instance.xano.com
+    access_token: <token>
+    workspace: <workspace_id>
+    branch: <branch_id>
+    run_project: <run_project_id>  # Used by xano run commands
+default: default
+```
 
 ## Help
 

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

@@ -40,7 +40,7 @@ export default class ProfileEdit extends BaseCommand {
         }),
         project: Flags.string({
             char: 'j',
-            description: 'Update project name',
+            description: 'Update project ID',
             required: false,
         }),
         'remove-workspace': Flags.boolean({

package/dist/commands/profile/wizard/index.d.ts

@@ -11,6 +11,7 @@ export default class ProfileWizard extends Command {
     private fetchWorkspaces;
     private fetchBranches;
     private fetchProjects;
+    private fetchRunProjects;
     private getDefaultProfileName;
     private saveProfile;
 }

package/dist/commands/profile/wizard/index.js

@@ -4,6 +4,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import * as yaml from 'js-yaml';
 import inquirer from 'inquirer';
+import { DEFAULT_RUN_BASE_URL } from '../../../lib/run-http-client.js';
 export default class ProfileWizard extends Command {
     static flags = {
         name: Flags.string({
@@ -191,6 +192,25 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
                     }
                 }
             }
+            // Step 7: Fetch run projects and auto-select the first one if no project was selected
+            this.log('');
+            this.log('Fetching available run projects...');
+            try {
+                const runProjects = await this.fetchRunProjects(accessToken);
+                if (runProjects.length > 0) {
+                    // Use run project if no metadata project was selected
+                    if (!project) {
+                        project = runProjects[0].id;
+                    }
+                    this.log(`✓ Found ${runProjects.length} run project(s). Using "${runProjects[0].name}" as default.`);
+                }
+                else {
+                    this.log('No run projects found. You can create one later with "xano run projects create".');
+                }
+            }
+            catch {
+                // Silently ignore - project will remain undefined
+            }
             // Save profile
             await this.saveProfile({
                 name: profileName,
@@ -357,6 +377,24 @@ Profile 'production' created successfully at ~/.xano/credentials.yaml
         }
         return [];
     }
+    async fetchRunProjects(accessToken, runBaseUrl = DEFAULT_RUN_BASE_URL) {
+        const baseUrl = runBaseUrl.endsWith('/') ? runBaseUrl.slice(0, -1) : runBaseUrl;
+        const response = await fetch(`${baseUrl}/api:run/project`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error('Unauthorized. Please check your access token.');
+            }
+            throw new Error(`API request failed with status ${response.status}`);
+        }
+        const data = (await response.json());
+        return Array.isArray(data) ? data : [];
+    }
     getDefaultProfileName() {
         try {
             const configDir = path.join(os.homedir(), '.xano');

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

@@ -0,0 +1,28 @@
+import BaseCommand from '../../../base-command.js';
+export default class Pull extends BaseCommand {
+    static args: {
+        directory: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    /**
+     * Parse a single document to extract its type, name, and optional verb.
+     * Skips leading comment lines (starting with //) to find the first
+     * meaningful line containing the type keyword and name.
+     */
+    private parseDocument;
+    /**
+     * Sanitize a document name for use as a filename.
+     * Strips quotes, replaces spaces with underscores, and removes
+     * characters that are unsafe in filenames.
+     */
+    private sanitizeFilename;
+    private loadCredentials;
+}

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

@@ -0,0 +1,238 @@
+import { Args, Flags } from '@oclif/core';
+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 = {
+        directory: Args.string({
+            description: 'Output directory for pulled documents',
+            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
+Pulled 42 documents to ./my-workspace
+`,
+        `$ xano workspace pull ./output -w 40
+Pulled 15 documents to ./output
+`,
+        `$ xano workspace pull ./backup --profile production --env --records
+Pulled 58 documents to ./backup
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Pull);
+        // 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`);
+        }
+        // Determine workspace_id from flag or profile
+        let workspaceId;
+        if (flags.workspace) {
+            workspaceId = flags.workspace;
+        }
+        else if (profile.workspace) {
+            workspaceId = profile.workspace;
+        }
+        else {
+            this.error(`Workspace ID is required. Either:\n` +
+                `  1. Provide it as a flag: xano workspace pull <directory> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile:edit ${profileName} -w <workspace_id>`);
+        }
+        // Build query parameters
+        const queryParams = new URLSearchParams({
+            env: flags.env.toString(),
+            records: flags.records.toString(),
+        });
+        // Construct the API URL
+        const apiUrl = `${profile.instance_origin}/api:meta/beta/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}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            responseText = await response.text();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to fetch multidoc: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to fetch multidoc: ${String(error)}`);
+            }
+        }
+        // Split the response into individual documents
+        const rawDocuments = responseText.split('\n---\n');
+        // Parse each document
+        const documents = [];
+        for (const raw of rawDocuments) {
+            const trimmed = raw.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const parsed = this.parseDocument(trimmed);
+            if (parsed) {
+                documents.push(parsed);
+            }
+        }
+        if (documents.length === 0) {
+            this.log('No documents found in response');
+            return;
+        }
+        // Resolve the output directory
+        const outputDir = path.resolve(args.directory);
+        // Create the output directory if it doesn't exist
+        fs.mkdirSync(outputDir, { recursive: true });
+        // Track filenames per type to handle duplicates
+        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}`;
+            }
+            // Track duplicates per type directory
+            if (!filenameCounters.has(doc.type)) {
+                filenameCounters.set(doc.type, new Map());
+            }
+            const typeCounters = filenameCounters.get(doc.type);
+            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`;
+            }
+            const filePath = path.join(typeDir, filename);
+            fs.writeFileSync(filePath, doc.content, 'utf8');
+            writtenCount++;
+        }
+        this.log(`Pulled ${writtenCount} documents to ${args.directory}`);
+    }
+    /**
+     * Parse a single document to extract its type, name, and optional verb.
+     * Skips leading comment lines (starting with //) to find the first
+     * meaningful line containing the type keyword and name.
+     */
+    parseDocument(content) {
+        const lines = content.split('\n');
+        // Find the first non-comment line
+        let firstLine = null;
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (trimmedLine && !trimmedLine.startsWith('//')) {
+                firstLine = trimmedLine;
+                break;
+            }
+        }
+        if (!firstLine) {
+            return null;
+        }
+        // Parse the type keyword and name from the first meaningful line
+        // Expected formats:
+        //   type name {
+        //   type name verb=GET {
+        //   type "name with spaces" {
+        //   type "name with spaces" verb=PATCH {
+        const match = firstLine.match(/^(\w+)\s+("(?:[^"\\]|\\.)*"|\S+)(?:\s+(.*))?/);
+        if (!match) {
+            return null;
+        }
+        const type = match[1];
+        let name = match[2];
+        const rest = match[3] || '';
+        // Strip surrounding quotes from the name
+        if (name.startsWith('"') && name.endsWith('"')) {
+            name = name.slice(1, -1);
+        }
+        // Extract verb if present (e.g., verb=GET)
+        let verb;
+        const verbMatch = rest.match(/verb=(\S+)/);
+        if (verbMatch) {
+            verb = verbMatch[1];
+        }
+        return { type, name, verb, content };
+    }
+    /**
+     * Sanitize a document name for use as a filename.
+     * Strips quotes, replaces spaces with underscores, and removes
+     * 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}`);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import BaseCommand from '../../../base-command.js';
+export default class Push 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>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * Recursively collect all .xs files from a directory, sorted by
+     * type subdirectory name then filename for deterministic ordering.
+     */
+    private collectFiles;
+    private loadCredentials;
+}

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

@@ -0,0 +1,163 @@
+import { Args, Flags } from '@oclif/core';
+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 = {
+        directory: Args.string({
+            description: 'Directory containing documents to push (as produced by workspace pull)',
+            required: true,
+        }),
+    };
+    static description = 'Push local documents to a workspace via the Xano Metadata API multidoc endpoint';
+    static examples = [
+        `$ xano workspace push ./my-workspace
+Pushed 42 documents from ./my-workspace
+`,
+        `$ xano workspace push ./output -w 40
+Pushed 15 documents from ./output
+`,
+        `$ xano workspace push ./backup --profile production
+Pushed 58 documents from ./backup
+`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (optional if set in profile)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Push);
+        // 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`);
+        }
+        // Determine workspace_id from flag or profile
+        let workspaceId;
+        if (flags.workspace) {
+            workspaceId = flags.workspace;
+        }
+        else if (profile.workspace) {
+            workspaceId = profile.workspace;
+        }
+        else {
+            this.error(`Workspace ID is required. Either:\n` +
+                `  1. Provide it as a flag: xano workspace push <directory> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile:edit ${profileName} -w <workspace_id>`);
+        }
+        // Resolve the input directory
+        const inputDir = path.resolve(args.directory);
+        if (!fs.existsSync(inputDir)) {
+            this.error(`Directory not found: ${inputDir}`);
+        }
+        if (!fs.statSync(inputDir).isDirectory()) {
+            this.error(`Not a directory: ${inputDir}`);
+        }
+        // Collect all .xs files from the directory tree
+        const files = this.collectFiles(inputDir);
+        if (files.length === 0) {
+            this.error(`No .xs files found in ${args.directory}`);
+        }
+        // Read each file and join with --- separator
+        const documents = [];
+        for (const filePath of files) {
+            const content = fs.readFileSync(filePath, 'utf8').trim();
+            if (content) {
+                documents.push(content);
+            }
+        }
+        if (documents.length === 0) {
+            this.error(`All .xs files in ${args.directory} are empty`);
+        }
+        const multidoc = documents.join('\n---\n');
+        // Construct the API URL
+        const apiUrl = `${profile.instance_origin}/api:meta/beta/workspace/${workspaceId}/multidoc`;
+        // POST the multidoc to the API
+        try {
+            const response = await fetch(apiUrl, {
+                method: 'POST',
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                    'Content-Type': 'text/x-xanoscript',
+                },
+                body: multidoc,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            // Log the response if any
+            const responseText = await response.text();
+            if (responseText) {
+                this.log(responseText);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to push multidoc: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to push multidoc: ${String(error)}`);
+            }
+        }
+        this.log(`Pushed ${documents.length} documents from ${args.directory}`);
+    }
+    /**
+     * Recursively collect all .xs files from a directory, sorted by
+     * type subdirectory name then filename for deterministic ordering.
+     */
+    collectFiles(dir) {
+        const files = [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...this.collectFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.xs')) {
+                files.push(fullPath);
+            }
+        }
+        return files.sort();
+    }
+    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/lib/base-run-command.js

@@ -39,7 +39,7 @@ export default class BaseRunCommand extends BaseCommand {
         await this.initRunCommand(profileFlag);
         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>'`);
         }
     }
     /**