@xano/cli 0.0.2

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

@@ -0,0 +1,350 @@
+import { Command, 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 inquirer from 'inquirer';
+export default class ProfileWizard extends Command {
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Profile name (skip prompt if provided)',
+            required: false,
+        }),
+        origin: Flags.string({
+            char: 'o',
+            description: 'Xano instance origin URL',
+            required: false,
+            default: 'https://app.xano.com',
+        }),
+    };
+    static description = 'Create a new profile configuration using an interactive wizard';
+    static examples = [
+        `$ xano profile:wizard
+Welcome to the Xano Profile Wizard!
+? Enter your access token: ***...***
+? Select an instance:
+  > Production (https://app.xano.com)
+    Staging (https://staging.xano.com)
+? Profile name: production
+Profile 'production' created successfully at ~/.xano/credentials.yaml
+`,
+    ];
+    async run() {
+        const { flags } = await this.parse(ProfileWizard);
+        this.log('Welcome to the Xano Profile Wizard!');
+        this.log('');
+        try {
+            // Step 1: Get access token
+            const { accessToken } = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'accessToken',
+                    message: 'Enter your access token',
+                    mask: '',
+                    validate: (input) => {
+                        if (!input || input.trim() === '') {
+                            return 'Access token cannot be empty';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            // Step 2: Fetch instances from API
+            this.log('');
+            this.log('Fetching available instances...');
+            let instances = [];
+            try {
+                instances = await this.fetchInstances(accessToken, flags.origin);
+            }
+            catch (error) {
+                this.error(`Failed to fetch instances: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (instances.length === 0) {
+                this.error('No instances found. Please check your access token.');
+            }
+            // Step 3: Let user select an instance
+            this.log('');
+            const { instanceId } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'instanceId',
+                    message: 'Select an instance',
+                    choices: instances.map((inst) => ({
+                        name: `${inst.name} (${inst.display})`,
+                        value: inst.id,
+                    })),
+                },
+            ]);
+            const selectedInstance = instances.find((inst) => inst.id === instanceId);
+            // Step 4: Get profile name
+            const defaultProfileName = flags.name || this.getDefaultProfileName();
+            const { profileName } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'profileName',
+                    message: 'Profile name',
+                    default: defaultProfileName,
+                    validate: (input) => {
+                        if (!input || input.trim() === '') {
+                            return 'Profile name cannot be empty';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            // Step 5: Workspace selection
+            let workspace;
+            let branch;
+            // Fetch workspaces from the selected instance
+            this.log('');
+            this.log('Fetching available workspaces...');
+            let workspaces = [];
+            try {
+                workspaces = await this.fetchWorkspaces(accessToken, selectedInstance.origin);
+            }
+            catch (error) {
+                this.warn(`Failed to fetch workspaces: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            // If workspaces were fetched, let user select one
+            if (workspaces.length > 0) {
+                this.log('');
+                const { selectedWorkspace } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedWorkspace',
+                        message: 'Select a workspace (or skip to use default)',
+                        choices: [
+                            { name: '(Skip workspace)', value: '' },
+                            ...workspaces.map((ws) => ({
+                                name: ws.name,
+                                value: ws.id,
+                            })),
+                        ],
+                    },
+                ]);
+                workspace = selectedWorkspace || undefined;
+                // If a workspace was selected, ask about branch preference
+                if (workspace) {
+                    this.log('');
+                    this.log('');
+                    this.log('Fetching available branches...');
+                    let branches = [];
+                    try {
+                        branches = await this.fetchBranches(accessToken, selectedInstance.origin, workspace);
+                    }
+                    catch (error) {
+                        this.warn(`Failed to fetch branches: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    // If branches were fetched, let user select one
+                    if (branches.length > 0) {
+                        this.log('');
+                        const { selectedBranch } = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedBranch',
+                                message: 'Select a branch',
+                                choices: [
+                                    { name: '(Skip and use live branch)', value: '' },
+                                    ...branches.map((br) => {
+                                        return {
+                                            name: br.label,
+                                            value: br.id,
+                                        };
+                                    }),
+                                ],
+                            },
+                        ]);
+                        branch = selectedBranch || undefined;
+                    }
+                }
+            }
+            // Save profile
+            await this.saveProfile({
+                name: profileName,
+                account_origin: flags.origin,
+                instance_origin: selectedInstance.origin,
+                access_token: accessToken,
+                workspace,
+                branch,
+            }, true);
+            this.log('');
+            this.log(`✓ Profile '${profileName}' created successfully!`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('User force closed the prompt')) {
+                this.log('Wizard cancelled.');
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    async fetchInstances(accessToken, origin) {
+        const response = await fetch(`${origin}/api:meta/instance`, {
+            method: 'GET',
+            headers: {
+                accept: '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());
+        // Transform API response to Instance format
+        // Assuming the API returns an array or object with instances
+        if (Array.isArray(data)) {
+            return data.map((inst) => ({
+                id: inst.id || inst.name,
+                name: inst.name,
+                display: inst.display,
+                origin: new URL(inst.meta_api).origin,
+            }));
+        }
+        // If it's an object, try to extract instances
+        if (data && typeof data === 'object') {
+            const instances = data.instances || data.data || [];
+            if (Array.isArray(instances)) {
+                return instances.map((inst) => ({
+                    id: inst.id || inst.name,
+                    name: inst.name,
+                    display: inst.display,
+                    origin: new URL(inst.meta_api).origin,
+                }));
+            }
+        }
+        return [];
+    }
+    async fetchWorkspaces(accessToken, origin) {
+        const response = await fetch(`${origin}/api:meta/workspace`, {
+            method: 'GET',
+            headers: {
+                accept: '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());
+        // Transform API response to Workspace format
+        // Assuming the API returns an array or object with workspaces
+        if (Array.isArray(data)) {
+            return data.map((ws) => ({
+                id: ws.id || ws.name,
+                name: ws.name,
+            }));
+        }
+        // If it's an object, try to extract workspaces
+        if (data && typeof data === 'object') {
+            const workspaces = data.workspaces || data.data || [];
+            if (Array.isArray(workspaces)) {
+                return workspaces.map((ws) => ({
+                    id: ws.id || ws.name,
+                    name: ws.name,
+                }));
+            }
+        }
+        return [];
+    }
+    async fetchBranches(accessToken, origin, workspaceId) {
+        const response = await fetch(`${origin}/api:meta/workspace/${workspaceId}/branch`, {
+            method: 'GET',
+            headers: {
+                accept: '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());
+        // Transform API response to Branch format
+        // Assuming the API returns an array or object with branches
+        if (Array.isArray(data)) {
+            return data.map((br) => ({
+                id: br.id || br.label,
+                label: br.label,
+            }));
+        }
+        // If it's an object, try to extract branches
+        if (data && typeof data === 'object') {
+            const branches = data.branches || data.data || [];
+            if (Array.isArray(branches)) {
+                return branches.map((br) => ({
+                    id: br.id || br.name,
+                    label: br.label,
+                }));
+            }
+        }
+        return [];
+    }
+    getDefaultProfileName() {
+        try {
+            const configDir = path.join(os.homedir(), '.xano');
+            const credentialsPath = path.join(configDir, 'credentials.yaml');
+            if (!fs.existsSync(credentialsPath)) {
+                return 'default';
+            }
+            const fileContent = fs.readFileSync(credentialsPath, 'utf8');
+            const parsed = yaml.load(fileContent);
+            if (parsed && typeof parsed === 'object' && 'default' in parsed && parsed.default) {
+                return parsed.default;
+            }
+            return 'default';
+        }
+        catch {
+            return 'default';
+        }
+    }
+    async saveProfile(profile, setAsDefault = false) {
+        const configDir = path.join(os.homedir(), '.xano');
+        const credentialsPath = path.join(configDir, 'credentials.yaml');
+        // Ensure the .xano directory exists
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        // Read existing credentials file or create new structure
+        let credentials = { profiles: {} };
+        if (fs.existsSync(credentialsPath)) {
+            try {
+                const fileContent = fs.readFileSync(credentialsPath, 'utf8');
+                const parsed = yaml.load(fileContent);
+                if (parsed && typeof parsed === 'object' && 'profiles' in parsed) {
+                    credentials = parsed;
+                }
+            }
+            catch (error) {
+                // Continue with empty credentials if parse fails
+            }
+        }
+        // Add or update the profile
+        credentials.profiles[profile.name] = {
+            account_origin: profile.account_origin,
+            instance_origin: profile.instance_origin,
+            access_token: profile.access_token,
+            ...(profile.workspace && { workspace: profile.workspace }),
+            ...(profile.branch && { branch: profile.branch }),
+        };
+        // Set as default if requested
+        if (setAsDefault) {
+            credentials.default = profile.name;
+        }
+        // Write the updated credentials back to the file
+        const yamlContent = yaml.dump(credentials, {
+            indent: 2,
+            lineWidth: -1,
+            noRefs: true,
+        });
+        fs.writeFileSync(credentialsPath, yamlContent, 'utf8');
+    }
+}

package/dist/commands/static_host/build/create/index.d.ts

@@ -0,0 +1,18 @@
+import BaseCommand from '../../../../base-command.js';
+export default class StaticHostBuildCreate extends BaseCommand {
+    static args: {
+        static_host: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        file: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private loadCredentials;
+}

package/dist/commands/static_host/build/create/index.js

@@ -0,0 +1,194 @@
+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 StaticHostBuildCreate extends BaseCommand {
+    static args = {
+        static_host: Args.string({
+            description: 'Static Host name',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (optional if set in profile)',
+            required: false,
+        }),
+        file: Flags.string({
+            char: 'f',
+            description: 'Path to zip file to upload',
+            required: true,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Build name',
+            required: true,
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Build description',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+    };
+    static description = 'Create a new build for a static host';
+    static examples = [
+        `$ xano static_host:build:create default -f ./build.zip -n "v1.0.0"
+Build created successfully!
+ID: 123
+Name: v1.0.0
+Status: pending
+`,
+        `$ xano static_host:build:create default -w 40 -f ./dist.zip -n "production" -d "Production build"
+Build created successfully!
+ID: 124
+Name: production
+Description: Production build
+`,
+        `$ xano static_host:build:create myhost -f ./app.zip -n "release-1.2" -o json
+{
+  "id": 125,
+  "name": "release-1.2",
+  "status": "pending"
+}
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(StaticHostBuildCreate);
+        // 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 static_host:build:create <static_host> -f <file> -n <name> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile:edit ${profileName} -w <workspace_id>`);
+        }
+        // Validate file exists
+        const filePath = path.resolve(flags.file);
+        if (!fs.existsSync(filePath)) {
+            this.error(`File not found: ${filePath}`);
+        }
+        // Check if file is readable
+        try {
+            fs.accessSync(filePath, fs.constants.R_OK);
+        }
+        catch {
+            this.error(`File is not readable: ${filePath}`);
+        }
+        // Get file stats
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile()) {
+            this.error(`Path is not a file: ${filePath}`);
+        }
+        // Construct the API URL
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${args.static_host}/build`;
+        // Create FormData
+        const FormData = (await import('node:buffer')).Blob;
+        const formData = new globalThis.FormData();
+        // Read file and create blob
+        const fileBuffer = fs.readFileSync(filePath);
+        const blob = new Blob([fileBuffer], { type: 'application/zip' });
+        formData.append('file', blob, path.basename(filePath));
+        formData.append('name', flags.name);
+        if (flags.description) {
+            formData.append('description', flags.description);
+        }
+        // Create build via API
+        try {
+            const response = await fetch(apiUrl, {
+                method: 'POST',
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+                body: formData,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            const result = await response.json();
+            // Validate response
+            if (!result || typeof result !== 'object') {
+                this.error('Unexpected API response format');
+            }
+            // Output results
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                // summary format
+                this.log('Build created successfully!');
+                this.log(`ID: ${result.id}`);
+                this.log(`Name: ${result.name}`);
+                if (result.status) {
+                    this.log(`Status: ${result.status}`);
+                }
+                if (flags.description) {
+                    this.log(`Description: ${flags.description}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to create build: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to create build: ${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/static_host/build/get/index.d.ts

@@ -0,0 +1,16 @@
+import BaseCommand from '../../../../base-command.js';
+export default class StaticHostBuildGet extends BaseCommand {
+    static args: {
+        static_host: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        build_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private loadCredentials;
+}