mo: platform-aware API client, sngine integration, Docker support

- Config auto-detects platform type (sngine vs Docker) and sets correct API paths
- Cloud client uses platform-aware endpoints for verify, think, tool-result
- API client works with both sngine-based and Docker control planes
- REST API now accepts Bearer tokens (agent auth) in addition to session cookies
- Fixed agent ID regex to support hyphens in IDs
- WebSocket relay running on agent.mona.expert:4390
- All 14 tests passing

src/api.js

@@ -4,29 +4,36 @@
 //   - Executing tools directly  
 //   - Testing connectivity
 //   - Managing agent registration
+//
+// Supports both sngine-based (agent.mona.expert) and Docker-based platforms.
 
 import { CLOUD, DEFAULTS } from './config.js';
 import { log } from './log.js';
 
 const UA = `mona-agent/${DEFAULTS.version}`;
+const P = CLOUD.paths; // platform-aware API paths
 
 // ── Generic fetch with auth ───────────────────────────────────────
-async function apiFetch(apiKey, path, { method = 'GET', body, signal } = {}) {
+async function apiFetch(apiKey, path, { method = 'GET', body, signal, headers: extraHeaders } = {}) {
   const url = CLOUD.base + path;
+  const headers = {
+    'authorization': `Bearer ${apiKey}`,
+    'content-type': 'application/json',
+    'user-agent': UA,
+    'x-mona-agent': DEFAULTS.version,
+    ...(extraHeaders || {}),
+  };
+
   const res = await fetch(url, {
     method,
-    headers: {
-      'authorization': `Bearer ${apiKey}`,
-      'content-type': 'application/json',
-      'user-agent': UA,
-      'x-mona-agent': DEFAULTS.version,
-    },
+    headers,
     body: body ? JSON.stringify(body) : undefined,
     signal,
   });
 
   if (!res.ok) {
-    const text = await res.text().catch(() => '');
+    let text;
+    try { text = await res.text(); } catch { text = ''; }
     const err = new Error(`API ${res.status}: ${text.slice(0, 200)}`);
     err.status = res.status;
     throw err;
@@ -37,23 +44,29 @@ async function apiFetch(apiKey, path, { method = 'GET', body, signal } = {}) {
 // ── Health check ──────────────────────────────────────────────────
 export async function checkHealth(apiKey) {
   try {
-    const res = await apiFetch(apiKey, '/health');
+    const res = await apiFetch(apiKey, P.health);
     const data = await res.json();
-    return { ok: true, ...data };
+    // Normalize response
+    return {
+      ok: true,
+      uptime: data.uptime || data.ok ? 1 : 0,
+      platform: CLOUD.platform,
+      ...data,
+    };
   } catch (err) {
-    return { ok: false, error: err.message };
+    return { ok: false, error: err.message, platform: CLOUD.platform };
   }
 }
 
 // ── Verify API key ────────────────────────────────────────────────
 export async function verifyKey(apiKey) {
-  const res = await apiFetch(apiKey, '/v1/auth/verify', { method: 'GET' });
+  const res = await apiFetch(apiKey, P.verifyKey, { method: 'GET' });
   return res.json();
 }
 
 // ── Send chat message ─────────────────────────────────────────────
 export async function sendChat(apiKey, agentId, message) {
-  const res = await apiFetch(apiKey, `/api/agents/${agentId}/chat`, {
+  const res = await apiFetch(apiKey, P.chat(agentId), {
     method: 'POST',
     body: { message },
   });
@@ -62,7 +75,7 @@ export async function sendChat(apiKey, agentId, message) {
 
 // ── Execute tool directly via API ─────────────────────────────────
 export async function execTool(apiKey, agentId, tool, args) {
-  const res = await apiFetch(apiKey, `/api/agents/${agentId}/tool`, {
+  const res = await apiFetch(apiKey, P.toolExec(agentId), {
     method: 'POST',
     body: { tool, args },
   });
@@ -71,19 +84,22 @@ export async function execTool(apiKey, agentId, tool, args) {
 
 // ── List agents ───────────────────────────────────────────────────
 export async function listAgents(apiKey) {
-  const res = await apiFetch(apiKey, '/api/agents');
-  return res.json();
+  // Sngine returns array directly, Docker returns { ok: true, agents: [...] }
+  const res = await apiFetch(apiKey, P.agents);
+  const data = await res.json();
+  if (Array.isArray(data)) return data;
+  return data.agents || data.agent || data;
 }
 
 // ── Get agent status ──────────────────────────────────────────────
 export async function getAgent(apiKey, agentId) {
-  const res = await apiFetch(apiKey, `/api/agents/${agentId}`);
+  const res = await apiFetch(apiKey, P.agents + '/' + agentId);
   return res.json();
 }
 
 // ── Stream reasoning from cloud (SSE) ─────────────────────────────
 export async function think({ apiKey, messages, tools, onChunk, onUsage, signal }) {
-  const res = await apiFetch(apiKey, '/v1/agent/think', {
+  const res = await apiFetch(apiKey, P.think, {
     method: 'POST',
     body: { messages, tools, stream: true },
   });
@@ -126,27 +142,33 @@ export async function think({ apiKey, messages, tools, onChunk, onUsage, signal
 }
 
 // ── Force connection test ─────────────────────────────────────────
-export async function testConnection(apiKey) {
+export async function testConnection(apiKey, targetUrl) {
+  // Override base temporarily if targetUrl provided
+  const base = targetUrl || CLOUD.base;
   const results = {};
 
-  // 1. Health check
-  log.info('Testing HTTP health...');
-  results.health = await checkHealth(apiKey);
-
-  // 2. Verify auth
-  log.info('Verifying API key...');
   try {
-    results.auth = await verifyKey(apiKey);
-  } catch (err) {
-    results.auth = { error: err.message };
-  }
+    log.info(`Testing ${base}...`);
 
-  // 3. List agents
-  log.info('Listing agents...');
-  try {
-    results.agents = await listAgents(apiKey);
+    // 1. Health check
+    results.health = await checkHealth(apiKey);
+
+    // 2. Verify auth
+    try {
+      results.auth = await verifyKey(apiKey);
+    } catch (err) {
+      results.auth = { error: err.message };
+    }
+
+    // 3. List agents
+    try {
+      const agents = await listAgents(apiKey);
+      results.agents = agents;
+    } catch (err) {
+      results.agents = { error: err.message };
+    }
   } catch (err) {
-    results.agents = { error: err.message };
+    results.error = err.message;
   }
 
   return results;

src/cloud.js

@@ -1,4 +1,5 @@
 // Cloud API client — all LLM reasoning runs remotely on agent.mona.expert.
+// Supports both sngine-based (agent.mona.expert) and Docker-based platforms.
 // This device sends prompts up and receives streamed reasoning back.
 // No LLM provider keys are ever stored or used locally.
 
@@ -6,18 +7,22 @@ import { CLOUD, DEFAULTS } from './config.js';
 import { log } from './log.js';
 
 const UA = `mona-agent/${DEFAULTS.version}`;
+const P = CLOUD.paths; // platform-aware API paths
 
 // ── Generic API fetch ─────────────────────────────────────────────
-async function apiFetch(path, { apiKey, method = 'POST', body, signal } = {}) {
+async function apiFetch(path, { apiKey, method = 'POST', body, signal, headers: extraHeaders } = {}) {
   const url = CLOUD.base + path;
+  const headers = {
+    'authorization': `Bearer ${apiKey}`,
+    'content-type':  'application/json',
+    'user-agent':    UA,
+    'x-mona-agent':  DEFAULTS.version,
+    ...(extraHeaders || {}),
+  };
+
   const res = await fetch(url, {
     method,
-    headers: {
-      'authorization':  `Bearer ${apiKey}`,
-      'content-type':   'application/json',
-      'user-agent':     UA,
-      'x-mona-agent':   DEFAULTS.version,
-    },
+    headers,
     body: body ? JSON.stringify(body) : undefined,
     signal,
   });
@@ -33,7 +38,7 @@ async function apiFetch(path, { apiKey, method = 'POST', body, signal } = {}) {
 
 // ── Verify API key ────────────────────────────────────────────────
 export async function verifyKey(apiKey) {
-  const res = await apiFetch('/v1/auth/verify', { apiKey, method: 'GET' });
+  const res = await apiFetch(P.verifyKey, { apiKey, method: 'GET' });
   return res.json();
 }
 
@@ -43,47 +48,62 @@ export async function verifyKey(apiKey) {
 // onUsage(usage) — called with final token counts (if provided)
 // Returns the full assembled response text.
 export async function think({ apiKey, messages, tools, onChunk, onUsage, signal }) {
-  const res = await apiFetch('/v1/agent/think', {
+  const res = await apiFetch(P.think, {
     apiKey,
     body: { messages, tools, stream: true },
     signal,
   });
 
-  const reader = res.body.getReader();
-  const dec = new TextDecoder();
-  let buf = '';
-  let full = '';
+  // Handle both SSE streaming and plain JSON responses
+  const contentType = res.headers.get('content-type') || '';
 
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
+  if (contentType.includes('text/event-stream')) {
+    // SSE streaming
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    let full = '';
 
-      buf += dec.decode(value, { stream: true });
-      const lines = buf.split('\n');
-      buf = lines.pop() || '';
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
 
-      for (const line of lines) {
-        if (!line.startsWith('data:')) continue;
-        const payload = line.slice(5).trim();
-        if (payload === '[DONE]') {
-          return full;
-        }
-        try {
-          const j = JSON.parse(payload);
-          if (j.delta) {
-            full += j.delta;
-            onChunk?.(j.delta);
+        buf += dec.decode(value, { stream: true });
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.startsWith('data:')) continue;
+          const payload = line.slice(5).trim();
+          if (payload === '[DONE]') return full;
+          try {
+            const j = JSON.parse(payload);
+            if (j.delta) {
+              full += j.delta;
+              onChunk?.(j.delta);
+            }
+            if (j.usage) onUsage?.(j.usage);
+          } catch {
+            // Skip malformed or keepalive lines
           }
-          if (j.usage) onUsage?.(j.usage);
-        } catch {
-          // Skip malformed or keepalive lines
         }
       }
+    } finally {
+      reader.releaseLock();
     }
-  } finally {
-    reader.releaseLock();
+    return full;
   }
 
-  return full;
+  // Plain JSON response
+  const data = await res.json();
+  return data.content || data.text || JSON.stringify(data);
+}
+
+// ── Report tool result to cloud ───────────────────────────────────
+export async function reportToolResult(apiKey, agentId, tool, result) {
+  return apiFetch(P.toolResult, {
+    apiKey,
+    body: { agentId, tool, result },
+  });
 }

src/config.js

@@ -1,32 +1,88 @@
 // Configuration & credential management.
+// Supports:
+//   - agent.mona.expert (sngine-based cloud) — default
+//   - Self-hosted Docker platform (port 4300)
+//   - Custom control planes via MONA_CLOUD / MONA_CLOUD_WS
+//
 // IMPORTANT: only the agent.mona.expert API key lives locally.
 // No LLM provider keys (OpenAI, Anthropic, etc.) are ever stored on this device.
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join, dirname } from 'node:path';
+import { join } from 'node:path';
 
 const DIR = join(homedir(), '.mona-agent');
 const CRED_FILE = join(DIR, 'credentials.json');
 const CONFIG_FILE = join(DIR, 'config.json');
 
 // ── Cloud endpoints ───────────────────────────────────────────────
-export const CLOUD = Object.freeze({
-  base: process.env.MONA_CLOUD || 'https://agent.mona.expert',
-  ws:   process.env.MONA_CLOUD_WS || null, // derived below if not set
+const baseUrl = process.env.MONA_CLOUD || 'https://agent.mona.expert';
+
+// Auto-detect platform type from URL
+function detectPlatform(url) {
+  try {
+    const host = new URL(url).host;
+    // Sngine-based: agent.mona.expert (and subdomains)
+    if (host.includes('mona.expert') && !url.includes(':4300')) return 'sngine';
+    // Docker platform: localhost:4300
+    if (url.includes(':4300')) return 'docker';
+    return 'sngine'; // default
+  } catch { return 'sngine'; }
+}
+
+const PLATFORM = detectPlatform(baseUrl);
+
+export const CLOUD = {
+  base:    baseUrl,
+  ws:      process.env.MONA_CLOUD_WS || null,
+  platform: PLATFORM,
+
   get wsUrl() {
     if (this.ws) return this.ws;
     const proto = this.base.startsWith('https') ? 'wss' : 'ws';
-    return `${proto}://${new URL(this.base).host}/?role=device`;
+    const host = new URL(this.base).host;
+
+    if (PLATFORM === 'docker') {
+      return `ws://${host}/ws?type=agent`;
+    }
+    // Sngine: WebSocket relay on same host, port 4390
+    // Nginx proxies /ws to localhost:4390
+    return `${proto}://${host}/ws?role=device`;
   },
-});
+
+  // API paths — vary by platform
+  get paths() {
+    if (PLATFORM === 'docker') {
+      return {
+        verifyKey:  '/api/keys/verify',
+        think:      '/api/llm/think',
+        health:     '/health',
+        agents:     '/api/agents',
+        chat:       (id) => `/api/agents/${id}/chat`,
+        toolExec:   (id) => `/api/agents/${id}/tool`,
+      };
+    }
+    // Sngine/mona.expert
+    return {
+      verifyKey:  '/api/v1/agent/verify',
+      think:      '/api/v1/agent/think',
+      toolResult: '/api/v1/agent/tool-result',
+      health:     '/api/v1/mona/system',       // uses system endpoint as health check
+      agents:     '/api/v1/mona/agents',
+      chat:       (id) => `/api/v1/mona/agents/${id}/chat`,
+      toolExec:   (id) => `/api/v1/mona/agents/${id}/tool`,
+    };
+  },
+};
+
+Object.freeze(CLOUD);
 
 // ── Agent defaults ────────────────────────────────────────────────
 export const DEFAULTS = Object.freeze({
   metricsIntervalMs: 10_000,
   reconnectMinMs:    1_000,
   reconnectMaxMs:    30_000,
-  version:           '1.0.0',
+  version:           '1.1.0',
 });
 
 // ── Credential management ─────────────────────────────────────────