@xano/cli 0.0.13 → 0.0.15

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

@@ -0,0 +1,73 @@
+/**
+ * Base command for all run commands
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as yaml from 'js-yaml';
+import BaseCommand from '../base-command.js';
+import { DEFAULT_RUN_BASE_URL, RunHttpClient } from './run-http-client.js';
+export default class BaseRunCommand extends BaseCommand {
+    httpClient;
+    profile;
+    profileName;
+    /**
+     * Initialize the run command with profile and HTTP client
+     */
+    async initRunCommand(profileFlag) {
+        this.profileName = profileFlag || this.getDefaultProfile();
+        const credentials = this.loadCredentials();
+        if (!(this.profileName in credentials.profiles)) {
+            this.error(`Profile '${this.profileName}' not found. Available profiles: ${Object.keys(credentials.profiles).join(', ')}\n` +
+                `Create a profile using 'xano profile:create'`);
+        }
+        this.profile = credentials.profiles[this.profileName];
+        if (!this.profile.access_token) {
+            this.error(`Profile '${this.profileName}' is missing access_token`);
+        }
+        const baseUrl = this.profile.run_base_url || DEFAULT_RUN_BASE_URL;
+        this.httpClient = new RunHttpClient({
+            baseUrl,
+            authToken: this.profile.access_token,
+            projectId: this.profile.project,
+        });
+    }
+    /**
+     * Initialize with project required
+     */
+    async initRunCommandWithProject(profileFlag) {
+        await this.initRunCommand(profileFlag);
+        if (!this.profile.project) {
+            this.error(`Profile '${this.profileName}' is missing project. ` +
+                `Update your profile with 'xano profile:edit --project <project-id>'`);
+        }
+    }
+    /**
+     * Load credentials from file
+     */
+    loadCredentials() {
+        const configDir = path.join(os.homedir(), '.xano');
+        const credentialsPath = path.join(configDir, 'credentials.yaml');
+        if (!fs.existsSync(credentialsPath)) {
+            this.error(`Credentials file not found at ${credentialsPath}\n` +
+                `Create a profile using 'xano profile:create'`);
+        }
+        try {
+            const fileContent = fs.readFileSync(credentialsPath, 'utf8');
+            const parsed = yaml.load(fileContent);
+            if (!parsed || typeof parsed !== 'object' || !('profiles' in parsed)) {
+                this.error('Credentials file has invalid format.');
+            }
+            return parsed;
+        }
+        catch (error) {
+            this.error(`Failed to parse credentials file: ${error}`);
+        }
+    }
+    /**
+     * Format a response for JSON output
+     */
+    outputJson(data) {
+        this.log(JSON.stringify(data, null, 2));
+    }
+}

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

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

package/dist/lib/run-http-client.js

@@ -0,0 +1,136 @@
+/**
+ * HTTP client for Xano Run API
+ * Based on @xano/run-sdk HttpClient
+ */
+export const DEFAULT_RUN_BASE_URL = 'https://app.xano.com/';
+export class RunHttpClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get the project ID
+     */
+    getProjectId() {
+        return this.config.projectId;
+    }
+    /**
+     * Build headers for a request
+     */
+    getHeaders(contentType = 'application/json') {
+        const headers = {
+            'Content-Type': contentType,
+            'Authorization': `Bearer ${this.config.authToken}`,
+        };
+        return headers;
+    }
+    /**
+     * Build a URL with optional query parameters
+     */
+    buildUrl(path, queryParams) {
+        const baseUrl = this.config.baseUrl.endsWith('/')
+            ? this.config.baseUrl.slice(0, -1)
+            : this.config.baseUrl;
+        const url = new URL(`${baseUrl}/api:run${path}`);
+        if (queryParams) {
+            for (const [key, value] of Object.entries(queryParams)) {
+                if (value !== undefined && value !== null) {
+                    if (typeof value === 'object') {
+                        url.searchParams.set(key, JSON.stringify(value));
+                    }
+                    else {
+                        url.searchParams.set(key, String(value));
+                    }
+                }
+            }
+        }
+        return url.toString();
+    }
+    /**
+     * Build a URL scoped to the current project
+     */
+    buildProjectUrl(path, queryParams) {
+        const projectId = this.config.projectId;
+        if (!projectId) {
+            throw new Error('Project ID is required. Set it in your profile.');
+        }
+        return this.buildUrl(`/project/${projectId}${path}`, queryParams);
+    }
+    /**
+     * Build a URL scoped to a specific session
+     */
+    buildSessionUrl(sessionId, path = '', queryParams) {
+        return this.buildUrl(`/session/${sessionId}${path}`, queryParams);
+    }
+    /**
+     * Make an HTTP request
+     */
+    async request(url, options) {
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+            error.status = response.status;
+            try {
+                error.response = await response.json();
+            }
+            catch {
+                error.response = await response.text();
+            }
+            throw error;
+        }
+        const text = await response.text();
+        if (!text) {
+            return undefined;
+        }
+        return JSON.parse(text);
+    }
+    /**
+     * Make a GET request
+     */
+    async get(url) {
+        return this.request(url, {
+            method: 'GET',
+            headers: this.getHeaders(),
+        });
+    }
+    /**
+     * Make a POST request with JSON body
+     */
+    async post(url, body) {
+        return this.request(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    /**
+     * Make a POST request with XanoScript body
+     */
+    async postXanoScript(url, code) {
+        return this.request(url, {
+            method: 'POST',
+            headers: this.getHeaders('text/x-xanoscript'),
+            body: code,
+        });
+    }
+    /**
+     * Make a PATCH request
+     */
+    async patch(url, body) {
+        return this.request(url, {
+            method: 'PATCH',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Make a DELETE request
+     */
+    async delete(url, body) {
+        return this.request(url, {
+            method: 'DELETE',
+            headers: this.getHeaders(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+}

package/dist/lib/run-types.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Types for Xano Run API
+ * Based on @xano/run-sdk types
+ */
+export interface PaginatedResponse<T> {
+    items: T[];
+    itemsReceived?: number;
+    curPage?: number;
+    nextPage?: number | null;
+    prevPage?: number | null;
+    offset?: number;
+    perPage?: number;
+    itemsTotal?: number;
+    pageTotal?: number;
+}
+export interface XanoRunError extends Error {
+    status?: number;
+    response?: unknown;
+}
+export interface Project {
+    id: string;
+    created_at: string;
+    name: string;
+    description: string;
+    user_id: number;
+    access: 'private' | 'public';
+}
+export interface CreateProjectInput {
+    name: string;
+    description: string;
+}
+export interface UpdateProjectInput {
+    name?: string;
+    description?: string;
+}
+export interface EnvKeysResponse {
+    env: string[];
+}
+export interface EnvValueResponse {
+    name: string;
+    value: string;
+}
+export interface UpdateEnvInput {
+    name: string;
+    env: {
+        name: string;
+        value: string;
+    };
+}
+export type SecretType = 'kubernetes.io/dockerconfigjson' | 'kubernetes.io/service-account-token';
+export interface SecretMetadata {
+    name: string;
+    type: SecretType;
+    repo?: string;
+}
+export interface SecretKeysResponse {
+    secrets: SecretMetadata[];
+}
+export interface SecretValueResponse {
+    name: string;
+    type: SecretType;
+    repo?: string;
+    value: string;
+}
+export interface UpdateSecretInput {
+    name: string;
+    secret: {
+        name: string;
+        type: SecretType;
+        value: string;
+        repo?: string;
+    };
+}
+export type RunType = 'job' | 'service';
+export interface RunOptions {
+    args?: Record<string, unknown>;
+    env?: Record<string, string>;
+}
+export interface RunBackup {
+    resource: string;
+    size: number;
+}
+export interface RunDefinition {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    name: string;
+    user_id: number;
+    project_id: string;
+    sig: string;
+    type: RunType;
+    args: unknown[] | Record<string, unknown>;
+    doc: string;
+}
+export interface SessionExecution {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    run_id: string;
+    batch_id: string | null;
+    state: 'complete' | 'error' | string;
+    error_msg: string;
+    response: unknown;
+    label: string;
+    boot_time: number;
+    pre_time: number;
+    main_time: number;
+    post_time: number;
+    total_time: number;
+    tenant_id: number;
+    access: string;
+    backup: RunBackup;
+    _run: RunDefinition;
+}
+export interface EndpointInput {
+    source: string;
+    name: string;
+    type: string;
+    nullable: boolean;
+    default: string;
+    required: boolean;
+}
+export interface Endpoint {
+    url: string;
+    verb: string;
+    input: EndpointInput[];
+}
+export interface MetadataApi {
+    url: string;
+}
+export interface RunResult {
+    run?: {
+        id?: string | number;
+        session?: SessionExecution;
+        result?: {
+            response?: unknown;
+            boot_time?: number;
+            main_time?: number;
+            pre_time?: number;
+            post_time?: number;
+            total_time?: number;
+        };
+        debug?: string[];
+        problems?: Array<{
+            message?: string;
+            severity?: string;
+        }>;
+    };
+    service?: {
+        id: number;
+        run: {
+            id: number;
+        };
+    };
+    logs?: unknown[];
+    result?: {
+        state?: 'complete';
+        response?: unknown;
+        boot_time?: number;
+        pre_time?: number;
+        main_time?: number;
+        post_time?: number;
+        total_time?: number;
+        pre_result?: unknown;
+        endpoints?: Endpoint[];
+        metadata_api?: MetadataApi;
+    };
+}
+export interface DocInfoResult {
+    type: RunType;
+    input?: Record<string, unknown>;
+    env?: string[];
+}
+export type SessionStatus = 'running' | 'stopped' | 'error';
+export interface Session {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    project_id: string;
+    state: string;
+}
+export interface SessionDetail {
+    id: string;
+    name: string;
+    status: SessionStatus;
+    uptime: number | null;
+    url?: string;
+    doc: string;
+    createdAt: string;
+    access: 'private' | 'public';
+    projectId: string | null;
+    backupResource: string | null;
+}
+export interface UpdateSessionInput {
+    name?: string;
+    access?: 'private' | 'public';
+}
+export interface TableColumn {
+    name: string;
+    type: string;
+    description?: string;
+    isPrimaryKey: boolean;
+}
+export interface RunLogEntry {
+    id: number;
+    created_at: string;
+    log_type: string;
+    duration: number;
+    function_name?: string;
+    error_msg: string;
+    log_object: object;
+    output?: string | Record<string, unknown>;
+    input?: unknown[];
+    stack?: unknown[];
+    value_store?: Record<string, unknown>;
+}
+export interface SinkTable {
+    guid: string;
+    name: string;
+    columns: TableColumn[];
+    content: Record<string, unknown>[];
+}
+export interface SinkData {
+    tables: SinkTable[];
+    logs: RunLogEntry[];
+}

package/dist/lib/run-types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for Xano Run API
+ * Based on @xano/run-sdk types
+ */
+export {};