clawsql 0.2.0 → 0.2.2

package/dist/cli/agent/openclaw-integration.js

@@ -39,7 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOpenClawGatewayReachable = exports.isDockerOpenClawContainerRunning = exports.OpenClawAgent = void 0;
+exports.isOpenClawGatewayReachable = exports.isDockerOpenClawContainerRunning = exports.SUPPORTED_PROVIDERS = exports.OpenClawAgent = void 0;
 exports.isDockerOpenClawAvailable = isDockerOpenClawAvailable;
 exports.isGatewayHealthy = isGatewayHealthy;
 exports.isLocalOpenClawAvailable = isLocalOpenClawAvailable;
@@ -51,27 +51,45 @@ exports.scheduleCron = scheduleCron;
 exports.sendNotification = sendNotification;
 exports.writeToMemory = writeToMemory;
 exports.createOpenClawAgent = createOpenClawAgent;
+exports.getModelProviderInfo = getModelProviderInfo;
+exports.configureModelProvider = configureModelProvider;
+exports.testOpenClawConnection = testOpenClawConnection;
+exports.getDetailedOpenClawStatus = getDetailedOpenClawStatus;
 exports.ensureOpenClawRunning = ensureOpenClawRunning;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const docker_prereq_js_1 = require("../utils/docker-prereq.js");
 // ============================================================================
 // Configuration
 // ============================================================================
-const DEFAULT_GATEWAY_URL = 'ws://localhost:18789';
-const DEFAULT_GATEWAY_TOKEN = 'clawsql-openclaw-token';
-const SESSION_ID = 'clawsql-session';
-const DEFAULT_TIMEOUT = 120000;
-const getGatewayUrl = () => process.env.OPENCLAW_GATEWAY_URL || DEFAULT_GATEWAY_URL;
-const getGatewayToken = () => process.env.OPENCLAW_GATEWAY_TOKEN || DEFAULT_GATEWAY_TOKEN;
+const CONFIG = {
+    gatewayUrl: process.env.OPENCLAW_GATEWAY_URL || 'ws://localhost:18789',
+    gatewayToken: process.env.OPENCLAW_GATEWAY_TOKEN || 'clawsql-openclaw-token',
+    sessionId: 'clawsql-session',
+    defaultTimeout: 120000,
+    healthCheckTimeout: 5000,
+    containerName: 'openclaw',
+};
+// Cached runtime detection
+let cachedRuntime;
+async function getContainerRuntime() {
+    if (cachedRuntime === undefined) {
+        cachedRuntime = await (0, docker_prereq_js_1.detectRuntime)();
+    }
+    return cachedRuntime;
+}
+// ============================================================================
+// Process Execution Utilities
+// ============================================================================
 /**
  * Execute a command and return the result
  */
 function execCommand(command, args, options) {
     return new Promise((resolve) => {
         const proc = (0, child_process_1.spawn)(command, args, {
-            timeout: options?.timeout || 30000,
+            timeout: options?.timeout ?? 30000,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: options?.env ? { ...process.env, ...options.env } : process.env,
         });
@@ -88,39 +106,146 @@ function execCommand(command, args, options) {
     });
 }
 /**
- * Execute openclaw CLI with gateway configuration
+ * Get spawn configuration for OpenClaw CLI execution
+ * Automatically uses container exec when OpenClaw is running in Docker/Podman
  */
-async function execOpenClaw(args, options) {
-    const gatewayUrl = options?.gatewayUrl || getGatewayUrl();
-    const gatewayToken = options?.gatewayToken || getGatewayToken();
-    const env = {};
-    if (gatewayUrl !== DEFAULT_GATEWAY_URL) {
-        env.OPENCLAW_GATEWAY_URL = gatewayUrl;
+async function getSpawnConfig(args) {
+    const isDocker = await isDockerOpenClawAvailable();
+    const runtime = isDocker ? await getContainerRuntime() : null;
+    // Environment variables to pass to OpenClaw
+    // Include all AI-related env vars for seamless integration
+    const env = {
+        OPENCLAW_GATEWAY_URL: CONFIG.gatewayUrl,
+        OPENCLAW_GATEWAY_TOKEN: CONFIG.gatewayToken,
+        // Anthropic/Claude configuration
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY ?? '',
+        ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL ?? '',
+        ANTHROPIC_MODEL: process.env.ANTHROPIC_MODEL ?? '',
+        // OpenAI configuration
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY ?? '',
+        OPENAI_BASE_URL: process.env.OPENAI_BASE_URL ?? '',
+        OPENAI_MODEL: process.env.OPENAI_MODEL ?? '',
+    };
+    if (runtime) {
+        // Execute inside container - pass env vars via -e flags
+        return {
+            command: runtime,
+            args: [
+                'exec',
+                '-e', 'OPENCLAW_GATEWAY_URL',
+                '-e', 'OPENCLAW_GATEWAY_TOKEN',
+                '-e', 'ANTHROPIC_API_KEY',
+                '-e', 'ANTHROPIC_BASE_URL',
+                '-e', 'ANTHROPIC_MODEL',
+                '-e', 'OPENAI_API_KEY',
+                '-e', 'OPENAI_BASE_URL',
+                '-e', 'OPENAI_MODEL',
+                CONFIG.containerName,
+                'openclaw',
+                ...args,
+            ],
+            env,
+        };
     }
-    env.OPENCLAW_GATEWAY_TOKEN = gatewayToken;
-    return execCommand('openclaw', args, { timeout: options?.timeout, env });
+    // Execute local CLI
+    return {
+        command: 'openclaw',
+        args,
+        env,
+    };
+}
+/**
+ * Spawn OpenClaw process with proper configuration
+ * Filters out internal log messages from stdout
+ */
+function spawnOpenClaw(args, options) {
+    return new Promise(async (resolve, reject) => {
+        const spawnConfig = await getSpawnConfig(args);
+        const timeout = options?.timeout ?? CONFIG.defaultTimeout;
+        const proc = (0, child_process_1.spawn)(spawnConfig.command, spawnConfig.args, {
+            timeout,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: spawnConfig.env,
+        });
+        let stdout = '';
+        let stderr = '';
+        /**
+         * Filter out OpenClaw internal log lines from output
+         * Log lines start with [bracket] pattern like [agents/...] or [xai-auth]
+         */
+        const filterLogLines = (text) => {
+            return text.split('\n')
+                .filter(line => !line.trim().startsWith('['))
+                .join('\n');
+        };
+        proc.stdout?.on('data', (data) => {
+            const chunk = data.toString();
+            stdout += chunk;
+            // Filter log lines when streaming to user
+            const filtered = filterLogLines(chunk);
+            if (filtered) {
+                options?.onChunk?.(filtered);
+            }
+        });
+        proc.stderr?.on('data', (data) => { stderr += data; });
+        // Abort signal handling
+        const abortHandler = () => {
+            proc.kill('SIGKILL');
+            reject(new DOMException('The operation was aborted', 'AbortError'));
+        };
+        if (options?.signal) {
+            if (options.signal.aborted) {
+                proc.kill('SIGKILL');
+                reject(new DOMException('The operation was aborted', 'AbortError'));
+                return;
+            }
+            options.signal.addEventListener('abort', abortHandler);
+        }
+        proc.on('close', (code) => {
+            options?.signal?.removeEventListener('abort', abortHandler);
+            if (code === 0) {
+                // Filter log lines from final output
+                resolve(filterLogLines(stdout).trim());
+            }
+            else if (code === null) {
+                reject(new DOMException('The operation was aborted', 'AbortError'));
+            }
+            else {
+                reject(new Error(`OpenClaw failed (exit ${code}): ${stderr || stdout}`));
+            }
+        });
+        proc.on('error', (err) => {
+            options?.signal?.removeEventListener('abort', abortHandler);
+            reject(new Error(`Failed to spawn openclaw: ${err.message}`));
+        });
+    });
 }
 // ============================================================================
 // Detection Functions
 // ============================================================================
 /**
- * Check if OpenClaw Docker container is running
+ * Check if OpenClaw container is running
  */
 async function isDockerOpenClawAvailable() {
-    const result = await execCommand('docker', [
-        'ps', '--filter', 'name=openclaw', '--filter', 'status=running',
-        '--format', '{{.Names}}'
+    const runtime = await getContainerRuntime();
+    if (!runtime)
+        return false;
+    const result = await execCommand(runtime, [
+        'ps',
+        '--filter', `name=${CONFIG.containerName}`,
+        '--filter', 'status=running',
+        '--format', '{{.Names}}',
     ]);
-    return result.success && result.stdout.trim() === 'openclaw';
+    return result.success && result.stdout.trim() === CONFIG.containerName;
 }
 /**
  * Check if OpenClaw gateway health endpoint responds
  */
 async function isGatewayHealthy() {
     try {
-        const httpUrl = getGatewayUrl().replace('ws://', 'http://').replace('wss://', 'https://');
+        const httpUrl = CONFIG.gatewayUrl.replace('ws://', 'http://').replace('wss://', 'https://');
         const response = await fetch(`${httpUrl}/health`, {
-            signal: AbortSignal.timeout(5000),
+            signal: AbortSignal.timeout(CONFIG.healthCheckTimeout),
         });
         return response.ok;
     }
@@ -129,22 +254,16 @@ async function isGatewayHealthy() {
     }
 }
 /**
- * Check if local OpenClaw CLI gateway is running (not Docker)
+ * Check if local OpenClaw CLI is running (not in container)
  */
 async function isLocalOpenClawAvailable() {
-    // Docker container takes precedence
-    if (await isDockerOpenClawAvailable()) {
+    if (await isDockerOpenClawAvailable())
         return false;
-    }
-    // Gateway must be reachable
-    if (!(await isGatewayHealthy())) {
+    if (!(await isGatewayHealthy()))
         return false;
-    }
-    // Verify via CLI status
-    const result = await execCommand('openclaw', ['status', '--json'], { timeout: 5000 });
-    if (!result.success) {
+    const result = await execCommand('openclaw', ['status', '--json'], { timeout: CONFIG.healthCheckTimeout });
+    if (!result.success)
         return false;
-    }
     try {
         const status = JSON.parse(result.stdout);
         return status.gateway?.mode === 'local' && !!status.gateway?.url;
@@ -154,255 +273,247 @@ async function isLocalOpenClawAvailable() {
     }
 }
 /**
- * Check if any OpenClaw gateway is available (Docker or local)
+ * Check if any OpenClaw is available
  */
 async function isOpenClawAvailable() {
     return (await isDockerOpenClawAvailable()) || (await isLocalOpenClawAvailable());
 }
 /**
- * Get detailed OpenClaw status
+ * Get OpenClaw status summary
  */
 async function getOpenClawStatus() {
     const [isDocker, isLocal] = await Promise.all([
         isDockerOpenClawAvailable(),
         isLocalOpenClawAvailable(),
     ]);
-    return {
-        available: isDocker || isLocal,
-        isDocker,
-        isLocal,
-    };
+    return { available: isDocker || isLocal, isDocker, isLocal };
 }
 // ============================================================================
 // Agent Functions
 // ============================================================================
 /**
- * Send a message to OpenClaw agent
+ * Build agent CLI arguments
  */
-async function sendToOpenClaw(message, options) {
-    const args = [
+function buildAgentArgs(message) {
+    return [
         'agent',
-        '--session-id', SESSION_ID,
+        '--local',
+        '--session-id', CONFIG.sessionId,
         '--message', message,
         '--thinking', 'minimal',
     ];
-    const timeout = options?.timeout || DEFAULT_TIMEOUT;
-    const gatewayUrl = options?.gatewayUrl || getGatewayUrl();
-    const gatewayToken = options?.gatewayToken || getGatewayToken();
-    return new Promise((resolve, reject) => {
-        const proc = (0, child_process_1.spawn)('openclaw', args, {
-            timeout,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                OPENCLAW_GATEWAY_URL: gatewayUrl,
-                OPENCLAW_GATEWAY_TOKEN: gatewayToken,
-            },
-        });
-        let stdout = '';
-        let stderr = '';
-        proc.stdout?.on('data', (data) => { stdout += data; });
-        proc.stderr?.on('data', (data) => { stderr += data; });
-        // Handle abort signal
-        const abortHandler = () => {
-            proc.kill('SIGKILL');
-            reject(new DOMException('The operation was aborted', 'AbortError'));
-        };
-        if (options?.signal) {
-            if (options.signal.aborted) {
-                proc.kill('SIGKILL');
-                reject(new DOMException('The operation was aborted', 'AbortError'));
-                return;
-            }
-            options.signal.addEventListener('abort', abortHandler);
-        }
-        proc.on('close', (code) => {
-            options?.signal?.removeEventListener('abort', abortHandler);
-            if (code === 0) {
-                resolve(stdout.trim());
-            }
-            else if (code === null) {
-                reject(new DOMException('The operation was aborted', 'AbortError'));
-            }
-            else {
-                reject(new Error(`OpenClaw agent failed: ${stderr || stdout}`));
-            }
-        });
-        proc.on('error', (err) => {
-            options?.signal?.removeEventListener('abort', abortHandler);
-            reject(new Error(`Failed to run openclaw: ${err.message}`));
-        });
-    });
 }
 /**
- * Send a message to OpenClaw with streaming output
+ * Send message to OpenClaw agent
+ */
+async function sendToOpenClaw(message, options) {
+    return spawnOpenClaw(buildAgentArgs(message), options);
+}
+/**
+ * Send message to OpenClaw with streaming output
  */
 async function sendToOpenClawStream(message, onChunk, options) {
-    const args = [
-        'agent',
-        '--session-id', SESSION_ID,
-        '--message', message,
-        '--thinking', 'minimal',
-    ];
-    const timeout = options?.timeout || DEFAULT_TIMEOUT;
-    const gatewayUrl = options?.gatewayUrl || getGatewayUrl();
-    const gatewayToken = options?.gatewayToken || getGatewayToken();
-    return new Promise((resolve, reject) => {
-        const proc = (0, child_process_1.spawn)('openclaw', args, {
-            timeout,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                OPENCLAW_GATEWAY_URL: gatewayUrl,
-                OPENCLAW_GATEWAY_TOKEN: gatewayToken,
-            },
-        });
-        let stdout = '';
-        let stderr = '';
-        proc.stdout?.on('data', (data) => {
-            const chunk = data.toString();
-            stdout += chunk;
-            onChunk(chunk);
-        });
-        proc.stderr?.on('data', (data) => { stderr += data; });
-        // Handle abort signal
-        const abortHandler = () => {
-            proc.kill('SIGKILL');
-            reject(new DOMException('The operation was aborted', 'AbortError'));
-        };
-        if (options?.signal) {
-            if (options.signal.aborted) {
-                proc.kill('SIGKILL');
-                reject(new DOMException('The operation was aborted', 'AbortError'));
-                return;
-            }
-            options.signal.addEventListener('abort', abortHandler);
-        }
-        proc.on('close', (code) => {
-            options?.signal?.removeEventListener('abort', abortHandler);
-            if (code === 0) {
-                resolve(stdout.trim());
-            }
-            else if (code === null) {
-                reject(new DOMException('The operation was aborted', 'AbortError'));
-            }
-            else {
-                reject(new Error(`OpenClaw agent failed: ${stderr || stdout}`));
-            }
-        });
-        proc.on('error', (err) => {
-            options?.signal?.removeEventListener('abort', abortHandler);
-            reject(new Error(`Failed to run openclaw: ${err.message}`));
-        });
-    });
+    return spawnOpenClaw(buildAgentArgs(message), { ...options, onChunk });
 }
 // ============================================================================
 // Cron & Notifications
 // ============================================================================
 /**
- * Schedule a cron job via OpenClaw
+ * Schedule a cron job
  */
 async function scheduleCron(name, schedule, prompt) {
-    const result = await execOpenClaw([
+    const spawnConfig = await getSpawnConfig([
         'cron', 'add',
         '--name', name,
         '--schedule', schedule,
         '--prompt', prompt,
-    ], { timeout: 10000 });
+    ]);
+    const result = await execCommand(spawnConfig.command, spawnConfig.args, { timeout: 10000, env: spawnConfig.env });
     if (!result.success) {
         throw new Error(`Failed to schedule cron: ${result.stderr || result.stdout}`);
     }
     return result.stdout.trim();
 }
 /**
- * Send a notification via OpenClaw channels
+ * Send notification via OpenClaw
  */
 async function sendNotification(to, message) {
-    const result = await execOpenClaw([
+    const spawnConfig = await getSpawnConfig([
         'message', 'send',
         '--to', to,
         '--message', message,
-    ], { timeout: 30000 });
+    ]);
+    const result = await execCommand(spawnConfig.command, spawnConfig.args, { timeout: 30000, env: spawnConfig.env });
     if (!result.success) {
-        throw new Error(`Failed to send message: ${result.stderr || result.stdout}`);
+        throw new Error(`Failed to send notification: ${result.stderr || result.stdout}`);
     }
     return result.stdout.trim();
 }
 /**
- * Write to OpenClaw memory
+ * Write to OpenClaw memory (local filesystem)
  */
 async function writeToMemory(content, filename = 'clawsql-cluster-state.md') {
     const memoryDir = path.join(os.homedir(), '.openclaw', 'memory');
     try {
         await fs.promises.mkdir(memoryDir, { recursive: true });
-        const filePath = path.join(memoryDir, filename);
-        await fs.promises.appendFile(filePath, `\n\n---\n\n${content}`);
+        await fs.promises.appendFile(path.join(memoryDir, filename), `\n\n---\n\n${content}`);
     }
     catch {
-        // Memory write is optional - silently ignore errors
+        // Silently ignore - memory is optional
     }
 }
 // ============================================================================
-// Agent Class
+// OpenClawAgent Class
 // ============================================================================
 /**
- * OpenClaw-backed AI agent
+ * OpenClaw-backed AI agent for ClawSQL
  */
 class OpenClawAgent {
     context;
-    _available = null;
-    constructor(ctx) {
-        this.context = ctx;
+    available = null;
+    constructor(context) {
+        this.context = context;
     }
     async isAvailable() {
-        if (this._available === null) {
-            this._available = await isOpenClawAvailable();
+        if (this.available === null) {
+            this.available = await isOpenClawAvailable();
         }
-        return this._available;
+        return this.available;
     }
     async process(input) {
         if (!(await this.isAvailable())) {
-            throw new Error('OpenClaw gateway is not running. Start it with: openclaw gateway');
+            throw new Error('OpenClaw not running. Start with: clawsql /start');
         }
-        const contextPrompt = this.buildContextPrompt();
-        return sendToOpenClaw(`${contextPrompt}\n\nUser query: ${input}`);
+        return sendToOpenClaw(`${this.buildContext()}\n\nUser: ${input}`);
     }
-    async scheduleHealthCheck(schedule = '0 * * * *') {
-        return scheduleCron('clawsql:health-check', schedule, 'Check MySQL cluster health using clawsql skill. Report any issues with instances, replication lag, or failover status.');
+    async healthCheckCron(schedule = '0 * * * *') {
+        return scheduleCron('clawsql:health-check', schedule, 'Check MySQL cluster health. Report issues with instances, replication, or failover.');
     }
     async alert(channel, message) {
-        return sendNotification(channel, `🦞 ClawSQL Alert: ${message}`);
+        return sendNotification(channel, `🦞 ClawSQL: ${message}`);
     }
-    buildContextPrompt() {
+    buildContext() {
         const { orchestrator, proxysql, failover } = this.context.settings;
-        return `You are the ClawSQL assistant. You have access to MySQL cluster management tools.
-
-Current configuration:
-- Orchestrator: ${orchestrator.url}
-- ProxySQL: ${proxysql.host}:${proxysql.adminPort}
-- Auto-failover: ${failover.autoFailoverEnabled ? 'enabled' : 'disabled'}
-
-Use the clawsql skill commands to answer questions about the MySQL cluster.`;
+        return `ClawSQL assistant for MySQL cluster management.
+Orchestrator: ${orchestrator.url}
+ProxySQL: ${proxysql.host}:${proxysql.adminPort}
+Auto-failover: ${failover.autoFailoverEnabled ? 'enabled' : 'disabled'}`;
     }
 }
 exports.OpenClawAgent = OpenClawAgent;
-/**
- * Create an OpenClaw agent instance
- */
 function createOpenClawAgent(ctx) {
     return new OpenClawAgent(ctx);
 }
 // ============================================================================
-// Backwards Compatibility Exports
+// Model Provider Configuration
+// ============================================================================
+exports.SUPPORTED_PROVIDERS = [
+    { id: 'anthropic', name: 'Anthropic (Claude)', envKey: 'ANTHROPIC_API_KEY' },
+    { id: 'openai', name: 'OpenAI (GPT)', envKey: 'OPENAI_API_KEY' },
+    { id: 'xai', name: 'xAI (Grok)', envKey: 'XAI_API_KEY' },
+    { id: 'mistral', name: 'Mistral', envKey: 'MISTRAL_API_KEY' },
+    { id: 'ollama', name: 'Ollama (Local)', envKey: null },
+    { id: 'custom', name: 'Custom Provider', envKey: 'CUSTOM_API_KEY' },
+];
+/**
+ * Get current model provider info
+ */
+async function getModelProviderInfo() {
+    const spawnConfig = await getSpawnConfig(['config', 'get', 'agents.defaults.model']);
+    const result = await execCommand(spawnConfig.command, spawnConfig.args, { timeout: CONFIG.healthCheckTimeout, env: spawnConfig.env });
+    if (!result.success || !result.stdout.trim()) {
+        return { provider: null, model: null, configured: false };
+    }
+    const model = result.stdout.trim();
+    const providerMatch = model.match(/^(\w+)\//);
+    return {
+        provider: providerMatch?.[1] ?? null,
+        model,
+        configured: !!model,
+    };
+}
+/**
+ * Configure model provider
+ */
+async function configureModelProvider(provider, apiKey, options) {
+    const providerInfo = exports.SUPPORTED_PROVIDERS.find(p => p.id === provider);
+    if (!providerInfo) {
+        return {
+            success: false,
+            message: `Unknown provider: ${provider}. Supported: ${exports.SUPPORTED_PROVIDERS.map(p => p.id).join(', ')}`,
+        };
+    }
+    const args = ['onboard', '--non-interactive', '--accept-risk'];
+    if (provider === 'ollama') {
+        args.push('--auth-choice', 'ollama');
+    }
+    else if (provider === 'custom') {
+        args.push('--auth-choice', 'custom-api-key');
+        if (apiKey)
+            args.push('--custom-api-key', apiKey);
+    }
+    else {
+        args.push('--auth-choice', `${provider}-api-key`);
+        if (apiKey)
+            args.push(`--${provider}-api-key`, apiKey);
+    }
+    if (options?.baseUrl)
+        args.push('--custom-base-url', options.baseUrl);
+    if (options?.modelId)
+        args.push('--custom-model-id', options.modelId);
+    const spawnConfig = await getSpawnConfig(args);
+    const result = await execCommand(spawnConfig.command, spawnConfig.args, { timeout: 30000, env: spawnConfig.env });
+    return {
+        success: result.success,
+        message: result.success
+            ? `Configured ${providerInfo.name}`
+            : `Failed: ${result.stderr || result.stdout}`,
+    };
+}
+/**
+ * Test OpenClaw connectivity
+ */
+async function testOpenClawConnection(query = 'Hello') {
+    const start = Date.now();
+    try {
+        const response = await sendToOpenClaw(query, { timeout: 30000 });
+        return { success: true, response, latencyMs: Date.now() - start };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs: Date.now() - start,
+        };
+    }
+}
+/**
+ * Get detailed status for display
+ */
+async function getDetailedOpenClawStatus() {
+    const status = await getOpenClawStatus();
+    const gatewayHealthy = status.available && await isGatewayHealthy();
+    const modelInfo = status.available ? await getModelProviderInfo() : { provider: null, model: null, configured: false };
+    return {
+        available: status.available,
+        mode: status.isDocker ? 'docker' : status.isLocal ? 'local' : 'unavailable',
+        gatewayHealthy,
+        modelInfo,
+        controlUI: 'http://localhost:18790',
+        gatewayUrl: CONFIG.gatewayUrl,
+    };
+}
+// ============================================================================
+// Backwards Compatibility
 // ============================================================================
-/** @deprecated Use isDockerOpenClawAvailable instead */
+/** @deprecated Use isDockerOpenClawAvailable */
 exports.isDockerOpenClawContainerRunning = isDockerOpenClawAvailable;
-/** @deprecated Use isGatewayHealthy instead */
+/** @deprecated Use isGatewayHealthy */
 exports.isOpenClawGatewayReachable = isGatewayHealthy;
-/** @deprecated Use getOpenClawStatus() or individual detection functions */
+/** @deprecated Use isGatewayHealthy() in a loop */
 async function ensureOpenClawRunning(timeoutSeconds = 30) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutSeconds * 1000) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
         if (await isGatewayHealthy())
             return true;
         await new Promise(r => setTimeout(r, 2000));