@xano/cli 0.0.13 → 0.0.15

package/dist/commands/run/env/get/index.js

@@ -0,0 +1,52 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunEnvGet extends BaseRunCommand {
+    static args = {
+        name: Args.string({
+            description: 'Environment variable name',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'value',
+            options: ['value', 'json'],
+        }),
+    };
+    static description = 'Get an environment variable value';
+    static examples = [
+        `$ xano run env get API_KEY
+my-secret-api-key
+`,
+        `$ xano run env get API_KEY -o json
+{ "name": "API_KEY", "value": "my-secret-api-key" }
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunEnvGet);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        try {
+            const url = this.httpClient.buildProjectUrl('/env', { name: args.name });
+            const result = await this.httpClient.get(url);
+            if (flags.output === 'json') {
+                this.outputJson(result);
+            }
+            else {
+                this.log(result.value);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to get environment variable: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to get environment variable: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/run/env/list/index.d.ts

@@ -0,0 +1,11 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunEnvList extends BaseRunCommand {
+    static args: {};
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/run/env/list/index.js

@@ -0,0 +1,58 @@
+import { Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunEnvList extends BaseRunCommand {
+    static args = {};
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'list',
+            options: ['list', 'json'],
+        }),
+    };
+    static description = 'List all environment variable keys';
+    static examples = [
+        `$ xano run env list
+Environment variables:
+  - API_KEY
+  - DATABASE_URL
+  - DEBUG
+`,
+        `$ xano run env list -o json
+{ "env": ["API_KEY", "DATABASE_URL", "DEBUG"] }
+`,
+    ];
+    async run() {
+        const { flags } = await this.parse(RunEnvList);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        try {
+            const url = this.httpClient.buildProjectUrl('/env/key');
+            const result = await this.httpClient.get(url);
+            if (flags.output === 'json') {
+                this.outputJson(result);
+            }
+            else {
+                if (result.env.length === 0) {
+                    this.log('No environment variables found.');
+                }
+                else {
+                    this.log('Environment variables:');
+                    for (const key of result.env) {
+                        this.log(`  - ${key}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to list environment variables: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to list environment variables: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/run/env/set/index.d.ts

@@ -0,0 +1,13 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunEnvSet extends BaseRunCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/run/env/set/index.js

@@ -0,0 +1,51 @@
+import { Args } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunEnvSet extends BaseRunCommand {
+    static args = {
+        name: Args.string({
+            description: 'Environment variable name',
+            required: true,
+        }),
+        value: Args.string({
+            description: 'Environment variable value',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+    };
+    static description = 'Set an environment variable';
+    static examples = [
+        `$ xano run env set API_KEY my-secret-key
+Environment variable 'API_KEY' set successfully!
+`,
+        `$ xano run env set DATABASE_URL "postgres://user:pass@host/db"
+Environment variable 'DATABASE_URL' set successfully!
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunEnvSet);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        const input = {
+            name: args.name,
+            env: {
+                name: args.name,
+                value: args.value,
+            },
+        };
+        try {
+            const url = this.httpClient.buildProjectUrl('/env');
+            await this.httpClient.patch(url, input);
+            this.log(`Environment variable '${args.name}' set successfully!`);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to set environment variable: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to set environment variable: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/{ephemeral/run/job → run/exec}/index.d.ts

@@ -1,5 +1,5 @@
-import BaseCommand from '../../../../base-command.js';
-export default class EphemeralRunJob extends BaseCommand {
+import BaseRunCommand from '../../../lib/base-run-command.js';
+export default class RunExec extends BaseRunCommand {
     static args: {};
     static flags: {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -7,13 +7,14 @@ export default class EphemeralRunJob extends BaseCommand {
         edit: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         args: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: 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>;
     };
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    private outputSummary;
     private editFile;
     private isUrl;
     private readStdin;
-    private loadCredentials;
 }

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

@@ -0,0 +1,353 @@
+import { Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import BaseRunCommand from '../../../lib/base-run-command.js';
+export default class RunExec extends BaseRunCommand {
+    static args = {};
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        file: Flags.string({
+            char: 'f',
+            description: 'Path or URL to file containing XanoScript code',
+            required: false,
+            exclusive: ['stdin'],
+        }),
+        stdin: Flags.boolean({
+            char: 's',
+            description: 'Read XanoScript code from stdin',
+            required: false,
+            default: false,
+            exclusive: ['file'],
+        }),
+        edit: Flags.boolean({
+            char: 'e',
+            description: 'Open file in editor before running (requires --file)',
+            required: false,
+            default: false,
+            dependsOn: ['file'],
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+        args: Flags.string({
+            char: 'a',
+            description: 'Path or URL to JSON file containing input arguments',
+            required: false,
+        }),
+        env: Flags.string({
+            description: 'Environment variable override (key=value)',
+            required: false,
+            multiple: true,
+        }),
+    };
+    static description = 'Execute XanoScript code (job or service)';
+    static examples = [
+        `$ xano run exec -f script.xs
+Executed successfully!
+...
+`,
+        `$ xano run exec -f script.xs --edit
+# Opens script.xs in $EDITOR, then executes
+Executed successfully!
+...
+`,
+        `$ cat script.xs | xano run exec --stdin
+Executed successfully!
+...
+`,
+        `$ xano run exec -f script.xs -o json
+{
+  "run": { ... }
+}
+`,
+        `$ xano run exec -f script.xs -a args.json
+# Executes with input arguments from args.json
+Executed successfully!
+...
+`,
+        `$ xano run exec -f script.xs --env API_KEY=secret --env DEBUG=true
+# Executes with environment variable overrides
+Executed successfully!
+...
+`,
+    ];
+    async run() {
+        const { flags } = await this.parse(RunExec);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        // Read XanoScript content
+        let xanoscript;
+        if (flags.file) {
+            if (this.isUrl(flags.file)) {
+                // Fetch URL content
+                try {
+                    const response = await fetch(flags.file);
+                    if (!response.ok) {
+                        this.error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
+                    }
+                    xanoscript = await response.text();
+                }
+                catch (error) {
+                    this.error(`Failed to fetch URL '${flags.file}': ${error}`);
+                }
+            }
+            else if (flags.edit) {
+                // If edit flag is set, copy to temp file and open in editor
+                const fileToRead = await this.editFile(flags.file);
+                xanoscript = fs.readFileSync(fileToRead, 'utf8');
+                // Clean up temp file
+                try {
+                    fs.unlinkSync(fileToRead);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            else {
+                try {
+                    xanoscript = fs.readFileSync(flags.file, 'utf8');
+                }
+                catch (error) {
+                    this.error(`Failed to read file '${flags.file}': ${error}`);
+                }
+            }
+        }
+        else if (flags.stdin) {
+            try {
+                xanoscript = await this.readStdin();
+            }
+            catch (error) {
+                this.error(`Failed to read from stdin: ${error}`);
+            }
+        }
+        else {
+            this.error('Either --file or --stdin must be specified to provide XanoScript code');
+        }
+        // Validate xanoscript is not empty
+        if (!xanoscript || xanoscript.trim().length === 0) {
+            this.error('XanoScript content is empty');
+        }
+        // Load args from JSON file or URL if provided
+        let inputArgs;
+        if (flags.args) {
+            if (this.isUrl(flags.args)) {
+                try {
+                    const response = await fetch(flags.args);
+                    if (!response.ok) {
+                        this.error(`Failed to fetch args URL: ${response.status} ${response.statusText}`);
+                    }
+                    const argsContent = await response.text();
+                    inputArgs = JSON.parse(argsContent);
+                }
+                catch (error) {
+                    this.error(`Failed to fetch or parse args '${flags.args}': ${error}`);
+                }
+            }
+            else {
+                try {
+                    const argsContent = fs.readFileSync(flags.args, 'utf8');
+                    inputArgs = JSON.parse(argsContent);
+                }
+                catch (error) {
+                    this.error(`Failed to read or parse args '${flags.args}': ${error}`);
+                }
+            }
+        }
+        // Parse env overrides
+        let envOverrides;
+        if (flags.env && flags.env.length > 0) {
+            envOverrides = {};
+            for (const envStr of flags.env) {
+                const eqIndex = envStr.indexOf('=');
+                if (eqIndex === -1) {
+                    this.error(`Invalid env format '${envStr}'. Expected format: key=value`);
+                }
+                const key = envStr.slice(0, eqIndex);
+                const value = envStr.slice(eqIndex + 1);
+                envOverrides[key] = value;
+            }
+        }
+        // Build query params
+        const queryParams = {};
+        if (inputArgs) {
+            queryParams.args = inputArgs;
+        }
+        if (envOverrides) {
+            queryParams.env = envOverrides;
+        }
+        // Execute via API
+        try {
+            const url = this.httpClient.buildProjectUrl('/run/exec', queryParams);
+            const result = await this.httpClient.postXanoScript(url, xanoscript);
+            // Output results
+            if (flags.output === 'json') {
+                this.outputJson(result);
+            }
+            else {
+                this.outputSummary(result);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to execute: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to execute: ${String(error)}`);
+            }
+        }
+    }
+    outputSummary(result) {
+        this.log('Executed successfully!');
+        this.log('');
+        // Handle service-specific output
+        if (result.service) {
+            this.log(`  Service ID: ${result.service.id}`);
+            this.log(`  Run ID:     ${result.service.run.id}`);
+            this.log('');
+        }
+        // Handle run/session info
+        if (result.run?.id) {
+            this.log(`  Run ID:     ${result.run.id}`);
+        }
+        if (result.run?.session) {
+            const session = result.run.session;
+            this.log(`  Session ID: ${session.id}`);
+            this.log(`  State:      ${session.state}`);
+            this.log('');
+        }
+        // Handle timing info
+        const timing = result.run?.result || result.run?.session || result.result;
+        if (timing) {
+            const formatTime = (time) => time !== undefined ? `${(time * 1000).toFixed(2)}ms` : undefined;
+            const times = [
+                { label: 'Total', value: formatTime(timing.total_time) },
+                { label: 'Boot', value: formatTime(timing.boot_time) },
+                { label: 'Main', value: formatTime(timing.main_time) },
+                { label: 'Pre', value: formatTime(timing.pre_time) },
+                { label: 'Post', value: formatTime(timing.post_time) },
+            ].filter(t => t.value !== undefined);
+            if (times.length > 0) {
+                this.log('  Timing:');
+                for (const t of times) {
+                    this.log(`    ${t.label.padEnd(6)} ${t.value}`);
+                }
+                this.log('');
+            }
+        }
+        // Handle service endpoints
+        if (result.result?.endpoints && result.result.endpoints.length > 0) {
+            this.log('  Endpoints:');
+            for (const endpoint of result.result.endpoints) {
+                this.log(`    ${endpoint.verb.padEnd(6)} ${endpoint.url}`);
+                if (endpoint.input.length > 0) {
+                    for (const input of endpoint.input) {
+                        const required = input.required ? '*' : '';
+                        const nullable = input.nullable ? '?' : '';
+                        this.log(`             └─ ${input.name}${required}: ${input.type}${nullable} (${input.source})`);
+                    }
+                }
+            }
+            this.log('');
+        }
+        // Handle metadata API
+        if (result.result?.metadata_api) {
+            this.log('  Metadata API:');
+            this.log(`    ${result.result.metadata_api.url}`);
+            this.log('');
+        }
+        // Handle response
+        const response = result.run?.result?.response ?? result.run?.session?.response ?? result.result?.response;
+        if (response !== undefined) {
+            this.log('  Response:');
+            const responseStr = typeof response === 'string'
+                ? response
+                : JSON.stringify(response, null, 2);
+            const indentedResponse = responseStr.split('\n').map((line) => `    ${line}`).join('\n');
+            this.log(indentedResponse);
+        }
+        // Handle problems/errors
+        if (result.run?.problems && result.run.problems.length > 0) {
+            this.log('');
+            this.log('  Problems:');
+            for (const problem of result.run.problems) {
+                this.log(`    - [${problem.severity}] ${problem.message}`);
+            }
+        }
+        if (result.run?.session?.error_msg) {
+            this.log('');
+            this.log(`  Error: ${result.run.session.error_msg}`);
+        }
+    }
+    // Editor value comes from EDITOR/VISUAL environment variables, not user input
+    async editFile(filePath) {
+        const editor = process.env.EDITOR || process.env.VISUAL;
+        if (!editor) {
+            this.error('No editor configured. Please set the EDITOR or VISUAL environment variable.\n' +
+                'Example: export EDITOR=vim');
+        }
+        // Validate editor executable exists
+        try {
+            execSync(`which ${editor.split(' ')[0]}`, { stdio: 'ignore' });
+        }
+        catch {
+            this.error(`Editor '${editor}' not found. Please set EDITOR to a valid editor.\n` +
+                'Example: export EDITOR=vim');
+        }
+        // Read the original file
+        let originalContent;
+        try {
+            originalContent = fs.readFileSync(filePath, 'utf8');
+        }
+        catch (error) {
+            this.error(`Failed to read file '${filePath}': ${error}`);
+        }
+        // Create a temporary file with the same extension
+        const ext = path.extname(filePath);
+        const tmpFile = path.join(os.tmpdir(), `xano-edit-${Date.now()}${ext}`);
+        // Copy content to temp file
+        try {
+            fs.writeFileSync(tmpFile, originalContent, 'utf8');
+        }
+        catch (error) {
+            this.error(`Failed to create temporary file: ${error}`);
+        }
+        // Open the editor
+        try {
+            execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            this.error(`Editor exited with an error: ${error}`);
+        }
+        return tmpFile;
+    }
+    isUrl(str) {
+        return str.startsWith('http://') || str.startsWith('https://');
+    }
+    async readStdin() {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            process.stdin.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            process.stdin.on('end', () => {
+                resolve(Buffer.concat(chunks).toString('utf8'));
+            });
+            process.stdin.on('error', (error) => {
+                reject(error);
+            });
+            process.stdin.resume();
+        });
+    }
+}

package/dist/commands/{ephemeral/run/service → run/info}/index.d.ts

@@ -1,18 +1,16 @@
-import BaseCommand from '../../../../base-command.js';
-export default class EphemeralRunService extends BaseCommand {
+import BaseRunCommand from '../../../lib/base-run-command.js';
+export default class RunInfo extends BaseRunCommand {
     static args: {};
     static flags: {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        edit: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         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 editFile;
+    private outputSummary;
     private isUrl;
     private readStdin;
-    private loadCredentials;
 }