@xano/cli 0.0.32 → 0.0.34

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

@@ -6,22 +6,22 @@ import * as path from 'node:path';
 import BaseCommand from '../../../base-command.js';
 export default class TenantGet extends BaseCommand {
     static args = {
-        tenant_id: Args.integer({
-            description: 'Tenant ID to retrieve',
+        tenant_name: Args.string({
+            description: 'Tenant name to retrieve',
             required: true,
         }),
     };
     static description = 'Get details of a specific tenant';
     static examples = [
-        `$ xano tenant get 42
-Tenant: My Tenant (my-tenant) - ID: 42
+        `$ xano tenant get t1234-abcd-xyz1
+Tenant: My Tenant (my-tenant)
   State: ok
   License: tier1
   Domain: my-tenant.xano.io
   Cluster: default
   Release: v1.0
 `,
-        `$ xano tenant get 42 -w 5 -o json`,
+        `$ xano tenant get t1234-abcd-xyz1 -w 5 -o json`,
     ];
     static flags = {
         ...BaseCommand.baseFlags,
@@ -57,8 +57,8 @@ Tenant: My Tenant (my-tenant) - ID: 42
         if (!workspaceId) {
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
-        const tenantId = args.tenant_id;
-        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantId}`;
+        const tenantName = args.tenant_name;
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}`;
         try {
             const response = await this.verboseFetch(apiUrl, {
                 headers: {
@@ -76,7 +76,7 @@ Tenant: My Tenant (my-tenant) - ID: 42
                 this.log(JSON.stringify(tenant, null, 2));
             }
             else {
-                this.log(`Tenant: ${tenant.display || tenant.name} (${tenant.name}) - ID: ${tenant.id}`);
+                this.log(`Tenant: ${tenant.display || tenant.name} (${tenant.name})`);
                 if (tenant.state)
                     this.log(`  State: ${tenant.state}`);
                 if (tenant.license)

package/dist/commands/tenant/list/index.js

@@ -87,7 +87,7 @@ Tenants in workspace 5:
                     for (const tenant of tenants) {
                         const state = tenant.state ? ` [${tenant.state}]` : '';
                         const license = tenant.license ? ` - ${tenant.license}` : '';
-                        this.log(`  - ${tenant.display || tenant.name} (${tenant.name}) (ID: ${tenant.id})${state}${license}`);
+                        this.log(`  - ${tenant.display || tenant.name} (${tenant.name})${state}${license}`);
                     }
                 }
             }

package/dist/commands/workflow_test/delete/index.d.ts

@@ -0,0 +1,21 @@
+import BaseCommand from '../../../base-command.js';
+export default class WorkflowTestDelete extends BaseCommand {
+    static args: {
+        workflow_test_id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    private confirm;
+    private loadCredentials;
+}

package/dist/commands/workflow_test/delete/index.js

@@ -0,0 +1,130 @@
+import { Args, Flags } from '@oclif/core';
+import * as readline from 'node:readline';
+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 WorkflowTestDelete extends BaseCommand {
+    static args = {
+        workflow_test_id: Args.integer({
+            description: 'ID of the workflow test to delete',
+            required: true,
+        }),
+    };
+    static description = 'Delete a workflow test';
+    static examples = [
+        `$ xano workflow-test delete 1
+Are you sure you want to delete workflow test 1? (y/N) y
+Deleted workflow test 1
+`,
+        `$ xano workflow-test delete 1 --force`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowTestDelete);
+        const profileName = flags.profile || this.getDefaultProfile();
+        const credentials = this.loadCredentials();
+        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];
+        if (!profile.instance_origin) {
+            this.error(`Profile '${profileName}' is missing instance_origin`);
+        }
+        if (!profile.access_token) {
+            this.error(`Profile '${profileName}' is missing access_token`);
+        }
+        const workspaceId = flags.workspace || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
+        }
+        if (!flags.force) {
+            const confirmed = await this.confirm(`Are you sure you want to delete workflow test ${args.workflow_test_id}? (y/N) `);
+            if (!confirmed) {
+                this.log('Deletion cancelled.');
+                return;
+            }
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/workflow_test/${args.workflow_test_id}`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+                method: 'DELETE',
+            }, flags.verbose, profile.access_token);
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            if (flags.output === 'json') {
+                this.log(JSON.stringify({ deleted: true, workflow_test_id: args.workflow_test_id }, null, 2));
+            }
+            else {
+                this.log(`Deleted workflow test ${args.workflow_test_id}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to delete workflow test: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to delete workflow test: ${String(error)}`);
+            }
+        }
+    }
+    async confirm(message) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(message, (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+            });
+        });
+    }
+    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}`);
+        }
+    }
+}

package/dist/commands/workflow_test/get/index.d.ts

@@ -0,0 +1,20 @@
+import BaseCommand from '../../../base-command.js';
+export default class WorkflowTestGet extends BaseCommand {
+    static args: {
+        workflow_test_id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'include-draft': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    private loadCredentials;
+}

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

@@ -0,0 +1,142 @@
+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 WorkflowTestGet extends BaseCommand {
+    static args = {
+        workflow_test_id: Args.integer({
+            description: 'ID of the workflow test',
+            required: true,
+        }),
+    };
+    static description = 'Get a specific workflow test';
+    static examples = [
+        `$ xano workflow-test get 1
+Workflow Test: my-test (ID: 1)
+  Description: Validates auth endpoints
+  Branch: main
+`,
+        `$ xano workflow-test get 1 -o xs`,
+        `$ xano workflow-test get 1 -o json`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'include-draft': Flags.boolean({
+            default: false,
+            description: 'Include draft version',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json', 'xs'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowTestGet);
+        const profileName = flags.profile || this.getDefaultProfile();
+        const credentials = this.loadCredentials();
+        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];
+        if (!profile.instance_origin) {
+            this.error(`Profile '${profileName}' is missing instance_origin`);
+        }
+        if (!profile.access_token) {
+            this.error(`Profile '${profileName}' is missing access_token`);
+        }
+        const workspaceId = flags.workspace || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
+        }
+        const params = new URLSearchParams({ include_xanoscript: 'true' });
+        if (flags['include-draft']) {
+            params.set('include_draft', 'true');
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/workflow_test/${args.workflow_test_id}?${params}`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+                method: 'GET',
+            }, flags.verbose, profile.access_token);
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            const test = await response.json();
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(test, null, 2));
+            }
+            else if (flags.output === 'xs') {
+                if (test.xanoscript?.status === 'ok' && test.xanoscript.value) {
+                    this.log(test.xanoscript.value);
+                }
+                else {
+                    this.error(`XanoScript not available: ${test.xanoscript?.message || 'unknown error'}`);
+                }
+            }
+            else {
+                this.log(`Workflow Test: ${test.name} (ID: ${test.id})`);
+                if (test.description) {
+                    this.log(`  Description: ${test.description}`);
+                }
+                if (test.branch?.name) {
+                    this.log(`  Branch: ${test.branch.name}`);
+                }
+                else if (test.branch?.id) {
+                    this.log(`  Branch ID: ${test.branch.id}`);
+                }
+                if (test.tag && test.tag.length > 0) {
+                    this.log(`  Tags: ${test.tag.join(', ')}`);
+                }
+                if (test.created_at) {
+                    this.log(`  Created: ${test.created_at}`);
+                }
+                if (test.updated_at) {
+                    this.log(`  Updated: ${test.updated_at}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to get workflow test: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to get workflow test: ${String(error)}`);
+            }
+        }
+    }
+    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}`);
+        }
+    }
+}

package/dist/commands/workflow_test/list/index.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../../base-command.js';
+export default class WorkflowTestList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    private loadCredentials;
+}

package/dist/commands/workflow_test/list/index.js

@@ -0,0 +1,129 @@
+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 BaseCommand from '../../../base-command.js';
+export default class WorkflowTestList extends BaseCommand {
+    static description = 'List all workflow tests in a workspace';
+    static examples = [
+        `$ xano workflow-test list
+Workflow tests in workspace 5:
+  - my-test (ID: 1)
+  - auth-flow (ID: 2) - Validates auth endpoints
+`,
+        `$ xano workflow-test list -w 5 --output json`,
+        `$ xano workflow-test list --branch main`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Filter by branch name',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowTestList);
+        const profileName = flags.profile || this.getDefaultProfile();
+        const credentials = this.loadCredentials();
+        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];
+        if (!profile.instance_origin) {
+            this.error(`Profile '${profileName}' is missing instance_origin`);
+        }
+        if (!profile.access_token) {
+            this.error(`Profile '${profileName}' is missing access_token`);
+        }
+        const workspaceId = flags.workspace || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
+        }
+        const params = new URLSearchParams({ include_xanoscript: 'false' });
+        if (flags.branch) {
+            params.set('branch', flags.branch);
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/workflow_test?${params}`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+                method: 'GET',
+            }, flags.verbose, profile.access_token);
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            const data = await response.json();
+            let tests;
+            if (Array.isArray(data)) {
+                tests = data;
+            }
+            else if (data && typeof data === 'object' && 'items' in data && Array.isArray(data.items)) {
+                tests = data.items;
+            }
+            else {
+                this.error('Unexpected API response format');
+            }
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(tests, null, 2));
+            }
+            else {
+                if (tests.length === 0) {
+                    this.log('No workflow tests found');
+                }
+                else {
+                    this.log(`Workflow tests in workspace ${workspaceId}:`);
+                    for (const test of tests) {
+                        const desc = test.description ? ` - ${test.description}` : '';
+                        this.log(`  - ${test.name} (ID: ${test.id})${desc}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to list workflow tests: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to list workflow tests: ${String(error)}`);
+            }
+        }
+    }
+    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}`);
+        }
+    }
+}

package/dist/commands/workflow_test/run/index.d.ts

@@ -0,0 +1,19 @@
+import BaseCommand from '../../../base-command.js';
+export default class WorkflowTestRun extends BaseCommand {
+    static args: {
+        workflow_test_id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    private loadCredentials;
+}

package/dist/commands/workflow_test/run/index.js

@@ -0,0 +1,119 @@
+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 WorkflowTestRun extends BaseCommand {
+    static args = {
+        workflow_test_id: Args.integer({
+            description: 'ID of the workflow test to run',
+            required: true,
+        }),
+    };
+    static description = 'Run a workflow test';
+    static examples = [
+        `$ xano workflow-test run 1
+Running workflow test 1...
+Result: PASS (1.234s)
+`,
+        `$ xano workflow-test run 1 -o json`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', 'json'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (uses profile workspace if not provided)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowTestRun);
+        const profileName = flags.profile || this.getDefaultProfile();
+        const credentials = this.loadCredentials();
+        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];
+        if (!profile.instance_origin) {
+            this.error(`Profile '${profileName}' is missing instance_origin`);
+        }
+        if (!profile.access_token) {
+            this.error(`Profile '${profileName}' is missing access_token`);
+        }
+        const workspaceId = flags.workspace || profile.workspace;
+        if (!workspaceId) {
+            this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/workflow_test/${args.workflow_test_id}/run`;
+        try {
+            if (flags.output === 'summary') {
+                this.log(`Running workflow test ${args.workflow_test_id}...`);
+            }
+            const response = await this.verboseFetch(apiUrl, {
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            }, flags.verbose, profile.access_token);
+            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();
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                const timing = `(${result.timing.toFixed(3)}s)`;
+                if (result.status === 'ok') {
+                    this.log(`Result: PASS ${timing}`);
+                }
+                else {
+                    this.log(`Result: FAIL ${timing}`);
+                    if (result.message) {
+                        this.log(`  Error: ${result.message}`);
+                    }
+                    this.exit(1);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to run workflow test: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to run workflow test: ${String(error)}`);
+            }
+        }
+    }
+    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}`);
+        }
+    }
+}

package/dist/commands/workflow_test/run_all/index.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../../base-command.js';
+export default class WorkflowTestRunAll extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    private loadCredentials;
+}