@xano/cli 0.0.14 → 0.0.16

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.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Base command for all run commands
+ */
+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;
+    branch?: string;
+    project?: string;
+    run_project?: string;
+    run_base_url?: string;
+}
+export interface CredentialsFile {
+    profiles: {
+        [key: string]: ProfileConfig;
+    };
+    default?: string;
+}
+export default abstract class BaseRunCommand extends BaseCommand {
+    protected httpClient: RunHttpClient;
+    protected profile: ProfileConfig;
+    protected profileName: string;
+    /**
+     * Initialize the run command with profile and HTTP client
+     */
+    protected initRunCommand(profileFlag?: string): Promise<void>;
+    /**
+     * Initialize with project required
+     */
+    protected initRunCommandWithProject(profileFlag?: string): Promise<void>;
+    /**
+     * Load credentials from file
+     */
+    protected loadCredentials(): CredentialsFile;
+    /**
+     * Format a response for JSON output
+     */
+    protected outputJson(data: unknown): void;
+}

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

@@ -0,0 +1,75 @@
+/**
+ * Base command for all run commands
+ */
+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 {
+    httpClient;
+    profile;
+    profileName;
+    /**
+     * Initialize the run command with profile and HTTP client
+     */
+    async initRunCommand(profileFlag) {
+        this.profileName = profileFlag || this.getDefaultProfile();
+        const credentials = this.loadCredentials();
+        if (!(this.profileName in credentials.profiles)) {
+            this.error(`Profile '${this.profileName}' not found. Available profiles: ${Object.keys(credentials.profiles).join(', ')}\n` +
+                `Create a profile using 'xano profile:create'`);
+        }
+        this.profile = credentials.profiles[this.profileName];
+        if (!this.profile.access_token) {
+            this.error(`Profile '${this.profileName}' is missing access_token`);
+        }
+        const baseUrl = this.profile.run_base_url || DEFAULT_RUN_BASE_URL;
+        // Use run_project if available, fall back to project for backward compatibility
+        const projectId = this.profile.run_project || this.profile.project;
+        this.httpClient = new RunHttpClient({
+            baseUrl,
+            authToken: this.profile.access_token,
+            projectId,
+        });
+    }
+    /**
+     * Initialize with project required
+     */
+    async initRunCommandWithProject(profileFlag) {
+        await this.initRunCommand(profileFlag);
+        if (!this.profile.run_project && !this.profile.project) {
+            this.error(`Profile '${this.profileName}' is missing run_project. ` +
+                `Run 'xano profile:wizard' to set up your profile or use 'xano profile:edit --run-project <project-id>'`);
+        }
+    }
+    /**
+     * Load credentials from file
+     */
+    loadCredentials() {
+        const configDir = path.join(os.homedir(), '.xano');
+        const credentialsPath = path.join(configDir, 'credentials.yaml');
+        if (!fs.existsSync(credentialsPath)) {
+            this.error(`Credentials file not found at ${credentialsPath}\n` +
+                `Create a profile using 'xano profile:create'`);
+        }
+        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}`);
+        }
+    }
+    /**
+     * Format a response for JSON output
+     */
+    outputJson(data) {
+        this.log(JSON.stringify(data, null, 2));
+    }
+}

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

@@ -0,0 +1,58 @@
+/**
+ * HTTP client for Xano Run API
+ * Based on @xano/run-sdk HttpClient
+ */
+export declare const DEFAULT_RUN_BASE_URL = "https://app.xano.com/";
+export interface RunHttpClientConfig {
+    baseUrl: string;
+    authToken: string;
+    projectId?: string;
+}
+export declare class RunHttpClient {
+    private readonly config;
+    constructor(config: RunHttpClientConfig);
+    /**
+     * Get the project ID
+     */
+    getProjectId(): string | undefined;
+    /**
+     * Build headers for a request
+     */
+    getHeaders(contentType?: string): HeadersInit;
+    /**
+     * Build a URL with optional query parameters
+     */
+    buildUrl(path: string, queryParams?: Record<string, unknown>): string;
+    /**
+     * Build a URL scoped to the current project
+     */
+    buildProjectUrl(path: string, queryParams?: Record<string, unknown>): string;
+    /**
+     * Build a URL scoped to a specific session
+     */
+    buildSessionUrl(sessionId: string, path?: string, queryParams?: Record<string, unknown>): string;
+    /**
+     * Make an HTTP request
+     */
+    request<T>(url: string, options: RequestInit): Promise<T>;
+    /**
+     * Make a GET request
+     */
+    get<T>(url: string): Promise<T>;
+    /**
+     * Make a POST request with JSON body
+     */
+    post<T>(url: string, body?: unknown): Promise<T>;
+    /**
+     * Make a POST request with XanoScript body
+     */
+    postXanoScript<T>(url: string, code: string): Promise<T>;
+    /**
+     * Make a PATCH request
+     */
+    patch<T>(url: string, body: unknown): Promise<T>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T>(url: string, body?: unknown): Promise<T>;
+}