@rigstate/cli 0.7.8 → 0.7.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rigstate/cli",
-    "version": "0.7.8",
+    "version": "0.7.10",
     "description": "Rigstate CLI - Code audit, sync and supervision tool",
     "type": "module",
     "main": "./dist/index.js",

package/src/daemon/core.ts

@@ -79,6 +79,7 @@ export class GuardianDaemon extends EventEmitter {
     private printWelcome() {
         console.log(chalk.bold.blue('\n🛡️  Guardian Daemon Starting...'));
         console.log(chalk.dim(`Project: ${this.config.projectId}`));
+        console.log(chalk.dim(`API URL: ${this.config.apiUrl}`));
         console.log(chalk.dim(`Watch Path: ${this.config.watchPath}`));
         console.log(chalk.dim('─'.repeat(50)));
     }

package/src/daemon/factory.ts

@@ -1,5 +1,5 @@
 import { GuardianDaemon } from './core.js';
-import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+import { getApiKey, getApiUrl, discoverApiUrl, getProjectId } from '../utils/config.js';
 import { loadManifest } from '../utils/manifest.js';
 import { DaemonConfig } from './types.js';
 
@@ -12,7 +12,9 @@ export async function createDaemon(options: {
     noBridge?: boolean;
     verbose?: boolean;
 }): Promise<GuardianDaemon> {
-    const apiUrl = getApiUrl();
+    // Force discovery on startup to find the correct local port if applicable
+    const apiUrl = await discoverApiUrl();
+
     let projectId = options.project;
 
     if (!projectId) {

package/src/daemon/guardian-monitor.ts

@@ -3,6 +3,7 @@
  */
 
 import axios from 'axios';
+import chalk from 'chalk';
 import fs from 'fs/promises';
 import path from 'path';
 import { checkFile, type EffectiveRule, type Violation, type CheckResult } from '../utils/rule-engine.js';
@@ -54,10 +55,17 @@ export function createGuardianMonitor(
                 await saveCachedRules(projectId, rules);
                 return;
             }
-        } catch (error) {
+        } catch (error: any) {
+            // Log error for debugging
+            console.error(chalk.red(`  ⚠️  Failed to fetch rules from API: ${error.message}`));
+            if (error.response) {
+                console.error(chalk.red(`     Status: ${error.response.status} - ${JSON.stringify(error.response.data)}`));
+            }
+
             // Try cache fallback
             const cached = await loadCachedRules(projectId);
             if (cached) {
+                console.log(chalk.yellow('  ℹ️  Using cached rules as fallback'));
                 rules = cached.rules;
                 lastFetch = Date.now();
                 return;

package/src/utils/config.ts

@@ -48,8 +48,14 @@ export function setProjectId(projectId: string): void {
     config.set('projectId', projectId);
 }
 
+// Basic check if a port is open - simplistic implementation for now
+// In a real scenario, we might want to actually ping /api/health
+// But for getApiUrl which is synchronous, we cannot easily do async checks.
+// So we will stick to the config/env value, BUT we will expose a separate
+// async function `discoverApiUrl` that the Daemon calls on startup.
+
 /**
- * Get the API URL
+ * Get the API URL (Synchronous)
  * Priority: Environment variable > Stored config > Production default
  */
 export function getApiUrl(): string {
@@ -66,6 +72,62 @@ export function getApiUrl(): string {
     return 'https://app.rigstate.com';
 }
 
+/**
+ * Discovers the active local API URL (Async)
+ * Scans ports 3000-3010 to find a responding Rigstate server.
+ */
+export async function discoverApiUrl(): Promise<string> {
+    const configuredUrl = getApiUrl();
+
+    // Dynamic import to avoid top-level await issues
+    const { default: axios } = await import('axios');
+    const { default: chalk } = await import('chalk');
+
+    console.log(chalk.gray(`🔍 Discovering local Rigstate API URL... Configured: ${configuredUrl}`));
+
+    // If not localhost, trust the config
+    if (!configuredUrl.includes('localhost') && !configuredUrl.includes('127.0.0.1')) {
+        console.log(chalk.gray(`   Configured URL is not localhost, trusting: ${configuredUrl}`));
+        return configuredUrl;
+    }
+
+    // Try to find the real port
+    const ports = [3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010];
+
+    for (const port of ports) {
+        const url = `http://localhost:${port}`;
+        try {
+            console.log(chalk.gray(`   Attempting to connect to ${url}/api/v1/system/health...`));
+            // Try the health endpoint
+            await axios.get(`${url}/api/v1/system/health`, { timeout: 800 });
+
+            console.log(chalk.green(`   ✅ Found Rigstate API at ${url}`));
+            if (url !== configuredUrl) {
+                console.log(chalk.gray(`   Updating stored API URL from ${configuredUrl} to ${url}`));
+                // Update config for next time
+                setApiUrl(url);
+            }
+            return url;
+        } catch (e: any) {
+            // Check if it's a 404 on the health endpoint - if so, it might still be our server
+            // But we prefer a positive match on health.
+            if (axios.isAxiosError(e) && e.response && e.response.status === 404) {
+                console.log(chalk.yellow(`   ⚠️ ${url} responded with 404, but might still be a Rigstate server. Skipping for now.`));
+            } else if (axios.isAxiosError(e) && e.code === 'ECONNABORTED') {
+                console.log(chalk.gray(`   Connection to ${url} timed out.`));
+            } else if (axios.isAxiosError(e) && e.code === 'ECONNREFUSED') {
+                console.log(chalk.gray(`   Connection to ${url} refused.`));
+            } else {
+                console.log(chalk.gray(`   Failed to connect to ${url}: ${e.message}`));
+            }
+            continue;
+        }
+    }
+
+    console.log(chalk.yellow(`   ❌ No local Rigstate API found on scanned ports. Falling back to configured URL: ${configuredUrl}`));
+    return configuredUrl;
+}
+
 /**
  * Set the API URL
  */