@xano/cli 0.0.26 → 0.0.28

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

@@ -1,10 +1,10 @@
 /**
  * Base command for all run commands
  */
+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 * 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 {
@@ -14,7 +14,7 @@ export default class BaseRunCommand extends BaseCommand {
     /**
      * Initialize the run command with profile and HTTP client
      */
-    async initRunCommand(profileFlag) {
+    async initRunCommand(profileFlag, verbose) {
         this.profileName = profileFlag || this.getDefaultProfile();
         const credentials = this.loadCredentials();
         if (!(this.profileName in credentials.profiles)) {
@@ -27,19 +27,21 @@ export default class BaseRunCommand extends BaseCommand {
         }
         const baseUrl = this.profile.run_base_url || DEFAULT_RUN_BASE_URL;
         this.httpClient = new RunHttpClient({
-            baseUrl,
             authToken: this.profile.access_token,
+            baseUrl,
+            logger: (msg) => this.log(msg),
             projectId: this.profile.project,
+            verbose,
         });
     }
     /**
      * Initialize with project required
      */
-    async initRunCommandWithProject(profileFlag) {
-        await this.initRunCommand(profileFlag);
+    async initRunCommandWithProject(profileFlag, verbose) {
+        await this.initRunCommand(profileFlag, verbose);
         if (!this.profile.project) {
             this.error(`Profile '${this.profileName}' is missing project. ` +
-                `Update your profile with 'xano profile:edit --project <project-id>'`);
+                `Run 'xano profile:wizard' to set up your profile or use 'xano profile:edit --project <project-id>'`);
         }
     }
     /**

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

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

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

@@ -2,27 +2,27 @@
  * HTTP client for Xano Run API
  * Based on @xano/run-sdk HttpClient
  */
-export const DEFAULT_RUN_BASE_URL = 'https://app.xano.com/';
+export const DEFAULT_RUN_BASE_URL = 'https://app.dev.xano.com/';
 export class RunHttpClient {
     config;
     constructor(config) {
         this.config = config;
     }
     /**
-     * Get the project ID
+     * Build a URL scoped to the current project
      */
-    getProjectId() {
-        return this.config.projectId;
+    buildProjectUrl(path, queryParams) {
+        const { projectId } = this.config;
+        if (!projectId) {
+            throw new Error('Project ID is required. Set it in your profile.');
+        }
+        return this.buildUrl(`/project/${projectId}${path}`, queryParams);
     }
     /**
-     * Build headers for a request
+     * Build a URL scoped to a specific session
      */
-    getHeaders(contentType = 'application/json') {
-        const headers = {
-            'Content-Type': contentType,
-            'Authorization': `Bearer ${this.config.authToken}`,
-        };
-        return headers;
+    buildSessionUrl(sessionId, path = '', queryParams) {
+        return this.buildUrl(`/session/${sessionId}${path}`, queryParams);
     }
     /**
      * Build a URL with optional query parameters
@@ -47,50 +47,48 @@ export class RunHttpClient {
         return url.toString();
     }
     /**
-     * Build a URL scoped to the current project
+     * Make a DELETE request
      */
-    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);
+    async delete(url, body) {
+        return this.request(url, {
+            body: body ? JSON.stringify(body) : undefined,
+            headers: this.getHeaders(),
+            method: 'DELETE',
+        });
     }
     /**
-     * Build a URL scoped to a specific session
+     * Make a GET request
      */
-    buildSessionUrl(sessionId, path = '', queryParams) {
-        return this.buildUrl(`/session/${sessionId}${path}`, queryParams);
+    async get(url) {
+        return this.request(url, {
+            headers: this.getHeaders(),
+            method: 'GET',
+        });
     }
     /**
-     * Make an HTTP request
+     * Build headers for a 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);
+    getHeaders(contentType = 'application/json') {
+        const headers = {
+            'Authorization': `Bearer ${this.config.authToken}`,
+            'Content-Type': contentType,
+        };
+        return headers;
     }
     /**
-     * Make a GET request
+     * Get the project ID
      */
-    async get(url) {
+    getProjectId() {
+        return this.config.projectId;
+    }
+    /**
+     * Make a PATCH request
+     */
+    async patch(url, body) {
         return this.request(url, {
-            method: 'GET',
+            body: JSON.stringify(body),
             headers: this.getHeaders(),
+            method: 'PATCH',
         });
     }
     /**
@@ -98,9 +96,9 @@ export class RunHttpClient {
      */
     async post(url, body) {
         return this.request(url, {
-            method: 'POST',
-            headers: this.getHeaders(),
             body: body ? JSON.stringify(body) : undefined,
+            headers: this.getHeaders(),
+            method: 'POST',
         });
     }
     /**
@@ -108,29 +106,66 @@ export class RunHttpClient {
      */
     async postXanoScript(url, code) {
         return this.request(url, {
-            method: 'POST',
-            headers: this.getHeaders('text/x-xanoscript'),
             body: code,
+            headers: this.getHeaders('text/x-xanoscript'),
+            method: 'POST',
         });
     }
     /**
-     * Make a PATCH request
+     * Make an HTTP request
      */
-    async patch(url, body) {
-        return this.request(url, {
-            method: 'PATCH',
-            headers: this.getHeaders(),
-            body: JSON.stringify(body),
-        });
+    async request(url, options) {
+        const method = options.method || 'GET';
+        const contentType = options.headers?.['Content-Type'] || 'application/json';
+        // Log request details
+        this.log(`\n${'─'.repeat(60)}`);
+        this.log(`→ ${method} ${url}`);
+        this.log(`  Content-Type: ${contentType}`);
+        if (options.body) {
+            const bodyPreview = typeof options.body === 'string'
+                ? options.body.length > 500 ? options.body.slice(0, 500) + '...' : options.body
+                : JSON.stringify(options.body);
+            this.log(`  Body: ${bodyPreview}`);
+        }
+        const startTime = Date.now();
+        const response = await fetch(url, options);
+        const elapsed = Date.now() - startTime;
+        // Log response details
+        this.log(`← ${response.status} ${response.statusText} (${elapsed}ms)`);
+        if (!response.ok) {
+            const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+            error.status = response.status;
+            try {
+                error.response = await response.json();
+                this.log(`  Response: ${JSON.stringify(error.response, null, 2)}`);
+            }
+            catch {
+                error.response = await response.text();
+                this.log(`  Response: ${error.response}`);
+            }
+            this.log(`${'─'.repeat(60)}\n`);
+            throw error;
+        }
+        const text = await response.text();
+        if (!text) {
+            this.log(`  Response: (empty)`);
+            this.log(`${'─'.repeat(60)}\n`);
+            return undefined;
+        }
+        const parsed = JSON.parse(text);
+        if (this.config.verbose) {
+            const responsePreview = text.length > 1000 ? text.slice(0, 1000) + '...' : text;
+            this.log(`  Response: ${responsePreview}`);
+        }
+        this.log(`${'─'.repeat(60)}\n`);
+        return parsed;
     }
     /**
-     * Make a DELETE request
+     * Log a message if verbose mode is enabled
      */
-    async delete(url, body) {
-        return this.request(url, {
-            method: 'DELETE',
-            headers: this.getHeaders(),
-            body: body ? JSON.stringify(body) : undefined,
-        });
+    log(message) {
+        if (this.config.verbose && this.config.logger) {
+            this.config.logger(message);
+        }
     }
 }

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

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