@xano/cli 0.0.18 → 0.0.20

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

@@ -25,11 +25,11 @@ export default abstract class BaseRunCommand extends BaseCommand {
     /**
      * Initialize the run command with profile and HTTP client
      */
-    protected initRunCommand(profileFlag?: string): Promise<void>;
+    protected initRunCommand(profileFlag?: string, verbose?: boolean): Promise<void>;
     /**
      * Initialize with project required
      */
-    protected initRunCommandWithProject(profileFlag?: string): Promise<void>;
+    protected initRunCommandWithProject(profileFlag?: string, verbose?: boolean): Promise<void>;
     /**
      * Load credentials from file
      */

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

@@ -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)) {
@@ -30,13 +30,15 @@ export default class BaseRunCommand extends BaseCommand {
             baseUrl,
             authToken: this.profile.access_token,
             projectId: this.profile.project,
+            verbose,
+            logger: (msg) => this.log(msg),
         });
     }
     /**
      * 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. ` +
                 `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

@@ -7,6 +7,8 @@ export interface RunHttpClientConfig {
     baseUrl: string;
     authToken: string;
     projectId?: string;
+    verbose?: boolean;
+    logger?: (message: string) => void;
 }
 export declare class RunHttpClient {
     private readonly config;
@@ -31,6 +33,10 @@ export declare class RunHttpClient {
      * Build a URL scoped to a specific session
      */
     buildSessionUrl(sessionId: string, path?: string, queryParams?: Record<string, unknown>): string;
+    /**
+     * Log a message if verbose mode is enabled
+     */
+    private log;
     /**
      * Make an HTTP request
      */

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

@@ -62,27 +62,62 @@ export class RunHttpClient {
     buildSessionUrl(sessionId, path = '', queryParams) {
         return this.buildUrl(`/session/${sessionId}${path}`, queryParams);
     }
+    /**
+     * Log a message if verbose mode is enabled
+     */
+    log(message) {
+        if (this.config.verbose && this.config.logger) {
+            this.config.logger(message);
+        }
+    }
     /**
      * Make an HTTP request
      */
     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;
         }
-        return JSON.parse(text);
+        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 GET request