@xano/cli 0.0.13 → 0.0.15

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

@@ -0,0 +1,62 @@
+import { Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSecretsList extends BaseRunCommand {
+    static args = {};
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'table',
+            options: ['table', 'json'],
+        }),
+    };
+    static description = 'List all secret keys';
+    static examples = [
+        `$ xano run secrets list
+NAME                TYPE                                  REPO
+docker-registry     kubernetes.io/dockerconfigjson        ghcr.io
+service-account     kubernetes.io/service-account-token   -
+`,
+        `$ xano run secrets list -o json
+{ "secrets": [{ "name": "docker-registry", "type": "kubernetes.io/dockerconfigjson", "repo": "ghcr.io" }] }
+`,
+    ];
+    async run() {
+        const { flags } = await this.parse(RunSecretsList);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        try {
+            const url = this.httpClient.buildProjectUrl('/secret/key');
+            const result = await this.httpClient.get(url);
+            if (flags.output === 'json') {
+                this.outputJson(result);
+            }
+            else {
+                if (result.secrets.length === 0) {
+                    this.log('No secrets found.');
+                }
+                else {
+                    // Print header
+                    this.log('NAME                     TYPE                                  REPO');
+                    this.log('-'.repeat(80));
+                    for (const secret of result.secrets) {
+                        const name = secret.name.slice(0, 24).padEnd(24);
+                        const type = secret.type.padEnd(37);
+                        const repo = secret.repo || '-';
+                        this.log(`${name} ${type} ${repo}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to list secrets: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to list secrets: ${String(error)}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSecretsSet extends BaseRunCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        value: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        repo: 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>;
+}

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

@@ -0,0 +1,74 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSecretsSet extends BaseRunCommand {
+    static args = {
+        name: Args.string({
+            description: 'Secret name',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Secret type',
+            required: true,
+            options: ['dockerconfigjson', 'service-account-token'],
+        }),
+        value: Flags.string({
+            char: 'v',
+            description: 'Secret value',
+            required: true,
+        }),
+        repo: Flags.string({
+            char: 'r',
+            description: 'Repository (for dockerconfigjson type)',
+            required: false,
+        }),
+    };
+    static description = 'Set a secret';
+    static examples = [
+        `$ xano run secrets set docker-registry -t dockerconfigjson -v '{"auths":{"ghcr.io":{"auth":"..."}}}' -r ghcr.io
+Secret 'docker-registry' set successfully!
+`,
+        `$ xano run secrets set service-key -t service-account-token -v 'token-value-here'
+Secret 'service-key' set successfully!
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunSecretsSet);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        // Map short type to full type
+        const typeMap = {
+            'dockerconfigjson': 'kubernetes.io/dockerconfigjson',
+            'service-account-token': 'kubernetes.io/service-account-token',
+        };
+        const secretType = typeMap[flags.type];
+        if (!secretType) {
+            this.error(`Invalid secret type: ${flags.type}`);
+        }
+        const input = {
+            name: args.name,
+            secret: {
+                name: args.name,
+                type: secretType,
+                value: flags.value,
+                ...(flags.repo && { repo: flags.repo }),
+            },
+        };
+        try {
+            const url = this.httpClient.buildProjectUrl('/secret');
+            await this.httpClient.patch(url, input);
+            this.log(`Secret '${args.name}' set successfully!`);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to set secret: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to set secret: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/run/sessions/delete/index.d.ts

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

package/dist/commands/run/sessions/delete/index.js

@@ -0,0 +1,65 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsDelete extends BaseRunCommand {
+    static args = {
+        sessionId: Args.string({
+            description: 'Session ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            required: false,
+            default: false,
+        }),
+    };
+    static description = 'Delete a session';
+    static examples = [
+        `$ xano run sessions delete abc123-def456
+Are you sure you want to delete session 'abc123-def456'? (y/N)
+Session deleted successfully!
+`,
+        `$ xano run sessions delete abc123-def456 --force
+Session deleted successfully!
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunSessionsDelete);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        // Confirm deletion unless --force is used
+        if (!flags.force) {
+            const readline = await import('node:readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const confirmed = await new Promise((resolve) => {
+                rl.question(`Are you sure you want to delete session '${args.sessionId}'? (y/N) `, (answer) => {
+                    rl.close();
+                    resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+                });
+            });
+            if (!confirmed) {
+                this.log('Deletion cancelled.');
+                return;
+            }
+        }
+        try {
+            const url = this.httpClient.buildProjectUrl(`/run/session/${args.sessionId}`);
+            await this.httpClient.delete(url);
+            this.log('Session deleted successfully!');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to delete session: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to delete session: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/run/sessions/get/index.d.ts

@@ -0,0 +1,13 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsGet extends BaseRunCommand {
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/sessions/get/index.js

@@ -0,0 +1,72 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsGet extends BaseRunCommand {
+    static args = {
+        sessionId: Args.string({
+            description: 'Session ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+    };
+    static description = 'Get session details';
+    static examples = [
+        `$ xano run sessions get abc123-def456
+Session Details:
+  ID:        abc123-def456
+  Name:      My Session
+  Status:    running
+  Access:    private
+  URL:       https://session.xano.io/abc123
+  Uptime:    3600s
+`,
+        `$ xano run sessions get abc123-def456 -o json
+{ "id": "abc123-def456", "name": "My Session", "status": "running", ... }
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunSessionsGet);
+        // Initialize (no project required for session details)
+        await this.initRunCommand(flags.profile);
+        try {
+            const url = this.httpClient.buildSessionUrl(args.sessionId);
+            const session = await this.httpClient.get(url);
+            if (flags.output === 'json') {
+                this.outputJson(session);
+            }
+            else {
+                this.log('Session Details:');
+                this.log(`  ID:        ${session.id}`);
+                this.log(`  Name:      ${session.name}`);
+                this.log(`  Status:    ${session.status}`);
+                this.log(`  Access:    ${session.access}`);
+                if (session.url) {
+                    this.log(`  URL:       ${session.url}`);
+                }
+                if (session.uptime !== null) {
+                    this.log(`  Uptime:    ${session.uptime}s`);
+                }
+                this.log(`  Created:   ${session.createdAt}`);
+                if (session.projectId) {
+                    this.log(`  Project:   ${session.projectId}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to get session: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to get session: ${String(error)}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsList 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>;
+    private outputTable;
+}

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

@@ -0,0 +1,64 @@
+import { Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsList extends BaseRunCommand {
+    static args = {};
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'table',
+            options: ['table', 'json'],
+        }),
+    };
+    static description = 'List all sessions for the project';
+    static examples = [
+        `$ xano run sessions list
+ID                                    STATE      CREATED
+abc123-def456-ghi789                  running    2024-01-15T10:30:00Z
+xyz789-uvw456-rst123                  stopped    2024-01-14T09:00:00Z
+`,
+        `$ xano run sessions list -o json
+{ "items": [{ "id": "abc123-def456-ghi789", "state": "running", ... }] }
+`,
+    ];
+    async run() {
+        const { flags } = await this.parse(RunSessionsList);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        try {
+            const url = this.httpClient.buildProjectUrl('/run/session');
+            const result = await this.httpClient.get(url);
+            if (flags.output === 'json') {
+                this.outputJson(result);
+            }
+            else {
+                this.outputTable(result.items);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to list sessions: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to list sessions: ${String(error)}`);
+            }
+        }
+    }
+    outputTable(sessions) {
+        if (sessions.length === 0) {
+            this.log('No sessions found.');
+            return;
+        }
+        // Print header
+        this.log('ID                                    STATE      CREATED');
+        this.log('-'.repeat(75));
+        for (const session of sessions) {
+            const id = session.id.padEnd(36);
+            const state = session.state.slice(0, 10).padEnd(10);
+            const created = session.created_at;
+            this.log(`${id}  ${state} ${created}`);
+        }
+    }
+}

package/dist/commands/run/sessions/start/index.d.ts

@@ -0,0 +1,13 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsStart extends BaseRunCommand {
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/sessions/start/index.js

@@ -0,0 +1,56 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsStart extends BaseRunCommand {
+    static args = {
+        sessionId: Args.string({
+            description: 'Session ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+    };
+    static description = 'Start a session';
+    static examples = [
+        `$ xano run sessions start abc123-def456
+Session started successfully!
+  ID:    abc123-def456
+  State: running
+`,
+        `$ xano run sessions start abc123-def456 -o json
+{ "id": "abc123-def456", "state": "running", ... }
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunSessionsStart);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        try {
+            const url = this.httpClient.buildProjectUrl(`/run/session/${args.sessionId}/start`);
+            const session = await this.httpClient.post(url, {});
+            if (flags.output === 'json') {
+                this.outputJson(session);
+            }
+            else {
+                this.log('Session started successfully!');
+                this.log(`  ID:    ${session.id}`);
+                this.log(`  State: ${session.state}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to start session: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to start session: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/run/sessions/stop/index.d.ts

@@ -0,0 +1,13 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsStop extends BaseRunCommand {
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/sessions/stop/index.js

@@ -0,0 +1,56 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSessionsStop extends BaseRunCommand {
+    static args = {
+        sessionId: Args.string({
+            description: 'Session ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+    };
+    static description = 'Stop a session';
+    static examples = [
+        `$ xano run sessions stop abc123-def456
+Session stopped successfully!
+  ID:    abc123-def456
+  State: stopped
+`,
+        `$ xano run sessions stop abc123-def456 -o json
+{ "id": "abc123-def456", "state": "stopped", ... }
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunSessionsStop);
+        // Initialize with project required
+        await this.initRunCommandWithProject(flags.profile);
+        try {
+            const url = this.httpClient.buildProjectUrl(`/run/session/${args.sessionId}/stop`);
+            const session = await this.httpClient.post(url, {});
+            if (flags.output === 'json') {
+                this.outputJson(session);
+            }
+            else {
+                this.log('Session stopped successfully!');
+                this.log(`  ID:    ${session.id}`);
+                this.log(`  State: ${session.state}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to stop session: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to stop session: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/run/sink/get/index.d.ts

@@ -0,0 +1,13 @@
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSinkGet extends BaseRunCommand {
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/sink/get/index.js

@@ -0,0 +1,63 @@
+import { Args, Flags } from '@oclif/core';
+import BaseRunCommand from '../../../../lib/base-run-command.js';
+export default class RunSinkGet extends BaseRunCommand {
+    static args = {
+        sessionId: Args.string({
+            description: 'Session ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseRunCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            description: 'Output format',
+            required: false,
+            default: 'summary',
+            options: ['summary', 'json'],
+        }),
+    };
+    static description = 'Get sink data for a completed session';
+    static examples = [
+        `$ xano run sink get abc123-def456
+Sink Data:
+  Tables: 3
+    - users (5 rows)
+    - orders (12 rows)
+    - products (8 rows)
+  Logs: 15 entries
+`,
+        `$ xano run sink get abc123-def456 -o json
+{ "tables": [...], "logs": [...] }
+`,
+    ];
+    async run() {
+        const { args, flags } = await this.parse(RunSinkGet);
+        // Initialize (no project required for sink data)
+        await this.initRunCommand(flags.profile);
+        try {
+            const url = this.httpClient.buildSessionUrl(args.sessionId, '/sink');
+            const sinkData = await this.httpClient.get(url);
+            if (flags.output === 'json') {
+                this.outputJson(sinkData);
+            }
+            else {
+                this.log('Sink Data:');
+                this.log(`  Tables: ${sinkData.tables.length}`);
+                for (const table of sinkData.tables) {
+                    const rowCount = table.content?.length || 0;
+                    this.log(`    - ${table.name} (${rowCount} rows)`);
+                }
+                this.log(`  Logs: ${sinkData.logs.length} entries`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to get sink data: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to get sink data: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/lib/base-run-command.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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_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;
+}