siclaw 0.1.0 → 0.1.2

package/dist/gateway/server.js

@@ -13,18 +13,23 @@ import { createDb, closeDb } from "./db/index.js";
 import { initSchema } from "./db/init-schema.js";
 import { ConfigRepository } from "./db/repositories/config-repo.js";
 import { NotificationRepository } from "./db/repositories/notification-repo.js";
+import { CronService } from "./cron/cron-service.js";
+import { ChatRepository } from "./db/repositories/chat-repo.js";
 import { PermissionRepository } from "./db/repositories/permission-repo.js";
 import { UserRepository } from "./db/repositories/user-repo.js";
 import { ModelConfigRepository } from "./db/repositories/model-config-repo.js";
 import { SystemConfigRepository } from "./db/repositories/system-config-repo.js";
 import { WorkspaceRepository } from "./db/repositories/workspace-repo.js";
 import { McpServerRepository } from "./db/repositories/mcp-server-repo.js";
-import { loadMcpServersConfig } from "../core/mcp-client.js";
+import { loadConfig } from "../core/config.js";
 import { buildMergedMcpConfig } from "./mcp-config-builder.js";
 import { CertificateManager } from "./security/cert-manager.js";
 import { createMtlsMiddleware } from "./security/mtls-middleware.js";
 import { createResourceNotifier } from "./resource-notifier.js";
 import { LocalSpawner } from "./agentbox/local-spawner.js";
+import { emitDiagnostic } from "../shared/diagnostic-events.js";
+import { checkMetricsAuth } from "../shared/metrics.js"; // also registers metrics subscriber (side-effect)
+import { MetricsAggregator } from "./metrics-aggregator.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Static files: web React build
 // Production: dist/gateway/web/dist/  Dev: src/gateway/web/dist/
@@ -40,7 +45,7 @@ const MIME_TYPES = {
     ".svg": "image/svg+xml",
     ".ico": "image/x-icon",
 };
-function serveStatic(res, urlPath) {
+function serveStatic(res, urlPath, frameSrc) {
     const withoutQuery = urlPath.split("?")[0];
     const safePath = path.normalize(withoutQuery).replace(/^(\.\.(\/|\\|$))+/, "");
     let filePath = path.join(WEB_DIR, safePath === "/" ? "index.html" : safePath);
@@ -66,7 +71,11 @@ function serveStatic(res, urlPath) {
     const ext = path.extname(filePath);
     const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
     const content = fs.readFileSync(filePath);
-    res.writeHead(200, { "Content-Type": contentType });
+    const headers = { "Content-Type": contentType };
+    if (frameSrc && contentType.startsWith("text/html")) {
+        headers["Content-Security-Policy"] = `frame-src 'self' ${frameSrc}`;
+    }
+    res.writeHead(200, headers);
     res.end(content);
 }
 export async function startGateway(opts) {
@@ -97,41 +106,22 @@ export async function startGateway(opts) {
     const db = await createDb();
     await initSchema(db);
     console.log("[gateway] Database initialized");
-    // Config repo for webhook route
+    // Config repo for webhook route + cron service
     const configRepo = db ? new ConfigRepository(db) : null;
-    // Clean orphan model entries on startup, then set up env resolver
+    const notifRepo = db ? new NotificationRepository(db) : null;
+    // In-process cron service (replaces standalone cron process)
+    const cronService = (configRepo && notifRepo)
+        ? new CronService({ configRepo, notifRepo, sendToUser, gatewayPort: config.port })
+        : null;
+    // System config repo (used by JWT, SSO, cert-manager, metrics cache, etc.)
+    const sysConfigRepo = db ? new SystemConfigRepository(db) : null;
+    // Clean orphan model entries on startup
     if (db) {
         const modelConfigRepo = new ModelConfigRepository(db);
         await modelConfigRepo.cleanOrphanModels();
-        agentBoxManager.setEnvResolver(async () => {
-            const env = {};
-            const llm = await modelConfigRepo.getResolvedDefaultConfig();
-            if (llm) {
-                if (llm.baseUrl)
-                    env.SICLAW_LLM_BASE_URL = llm.baseUrl;
-                if (llm.apiKey)
-                    env.SICLAW_LLM_API_KEY = resolveApiKey(llm.apiKey);
-                if (llm.model)
-                    env.SICLAW_LLM_MODEL = llm.model;
-            }
-            const emb = await modelConfigRepo.getResolvedEmbeddingConfig();
-            if (emb) {
-                if (emb.baseUrl)
-                    env.SICLAW_EMBEDDING_BASE_URL = emb.baseUrl;
-                if (emb.apiKey)
-                    env.SICLAW_EMBEDDING_API_KEY = resolveApiKey(emb.apiKey);
-                if (emb.model)
-                    env.SICLAW_EMBEDDING_MODEL = emb.model;
-                if (emb.dimensions)
-                    env.SICLAW_EMBEDDING_DIMENSIONS = String(emb.dimensions);
-            }
-            return env;
-        });
     }
     // Workspace repo (used by internal API to resolve default workspace)
     const internalWorkspaceRepo = db ? new WorkspaceRepository(db) : null;
-    // System config repo (used by JWT, SSO, cert-manager, etc.)
-    const sysConfigRepo = db ? new SystemConfigRepository(db) : null;
     // Initialize Certificate Manager for mTLS (CA persisted in DB)
     const certManager = await CertificateManager.create(sysConfigRepo);
     agentBoxManager.setCertManager(certManager);
@@ -154,18 +144,80 @@ export async function startGateway(opts) {
         ? (type, userId) => localSpawner.reloadResource(type, userId)
         : undefined;
     const resourceNotifier = createResourceNotifier(agentBoxManager, agentBoxTlsOptions, localReloader);
+    // Create MetricsAggregator (Local mode: proxy LocalCollector; K8s mode: pull loop)
+    const isK8sMode = !(spawner instanceof LocalSpawner);
+    let metricsAggregator;
+    if (isK8sMode) {
+        metricsAggregator = new MetricsAggregator("k8s", undefined, agentBoxManager, {
+            async fetch(endpoint) {
+                try {
+                    const client = new AgentBoxClient(endpoint, 3000, agentBoxTlsOptions);
+                    return await client.getJson("/api/internal/metrics-snapshot");
+                }
+                catch {
+                    return null;
+                }
+            },
+        });
+    }
+    else {
+        const { localCollector } = await import("../shared/local-collector.js");
+        metricsAggregator = new MetricsAggregator("local", localCollector);
+    }
+    if (db)
+        metricsAggregator.setDb(db);
+    // CSP frame-src cache for Grafana iframe embedding
+    let cachedFrameSrc = null;
+    const refreshCspCache = async () => {
+        if (!sysConfigRepo)
+            return;
+        try {
+            const url = await sysConfigRepo.get("system.grafanaUrl");
+            cachedFrameSrc = url ? new URL(url).origin : null;
+        }
+        catch {
+            cachedFrameSrc = null;
+        }
+    };
+    await refreshCspCache();
+    // Metrics config cache — Gateway reads from DB, falls back to env var
+    let cachedMetricsToken;
+    const refreshMetricsConfig = async () => {
+        if (!sysConfigRepo)
+            return;
+        try {
+            cachedMetricsToken = (await sysConfigRepo.get("metrics.token")) ?? undefined;
+        }
+        catch { /* keep previous cachedMetricsToken */ }
+        try {
+            const userIdVal = await sysConfigRepo.get("metrics.includeUserId");
+            if (userIdVal !== null) {
+                const { setIncludeUserId } = await import("../shared/metrics.js");
+                setIncludeUserId(userIdVal !== "false");
+            }
+        }
+        catch { /* keep previous includeUserId */ }
+    };
+    await refreshMetricsConfig();
     // Create RPC methods using AgentBoxManager
-    const { methods: rpcMethods, buildCredentialPayload, getSkillBundle, cleanupForWs } = createRpcMethods(agentBoxManager, broadcast, db, sendToUser, activePromptUsers, agentBoxTlsOptions, resourceNotifier);
+    const { methods: rpcMethods, buildCredentialPayload, getSkillBundle, cleanupForWs } = createRpcMethods(agentBoxManager, broadcast, db, sendToUser, activePromptUsers, agentBoxTlsOptions, resourceNotifier, metricsAggregator, cronService);
+    // Wrap system.saveSection to refresh caches when settings change
+    const origSaveSection = rpcMethods.get("system.saveSection");
+    if (origSaveSection) {
+        rpcMethods.set("system.saveSection", async (params, context) => {
+            const result = await origSaveSection(params, context);
+            const section = params.section;
+            if (section === "system")
+                await refreshCspCache();
+            if (section === "metrics")
+                await refreshMetricsConfig();
+            return result;
+        });
+    }
     // Wire skill bundle provider into LocalSpawner (getSkillBundle comes from createRpcMethods)
     if (localSpawner) {
         localSpawner.setSkillBundleProvider(getSkillBundle);
     }
-    // Apply DB-stored agentbox image override (takes effect on next pod spawn)
-    if (sysConfigRepo) {
-        const img = await sysConfigRepo.get("system.agentboxImage");
-        if (img)
-            agentBoxManager.setSpawnerImage(img);
-    }
     // Auth setup — auto-generate JWT secret on first run if not provided
     const jwtSecret = await resolveJwtSecret(sysConfigRepo);
     const userStore = new UserStore(db);
@@ -327,6 +379,25 @@ export async function startGateway(opts) {
             res.end(JSON.stringify({ status: "ok" }));
             return;
         }
+        // Prometheus metrics endpoint
+        if (url === "/metrics" && method === "GET") {
+            if (!checkMetricsAuth(req, res, cachedMetricsToken))
+                return;
+            (async () => {
+                try {
+                    const { metricsRegistry } = await import("../shared/metrics.js");
+                    const metricsBody = await metricsRegistry.metrics();
+                    res.writeHead(200, { "Content-Type": metricsRegistry.contentType });
+                    res.end(metricsBody);
+                }
+                catch (err) {
+                    console.error("[gateway] /metrics error:", err);
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Internal server error" }));
+                }
+            })();
+            return;
+        }
         // Login API
         if (url === "/api/login") {
             handleLogin(req, res);
@@ -455,171 +526,6 @@ export async function startGateway(opts) {
         }
         // NOTE: /api/internal/cron-list has been moved to HTTPS server (port 3002)
         // with mTLS authentication for AgentBox access only.
-        // ─── Internal cron coordination API (used by cron service) ────────
-        // These thin wrappers let cron-main talk to the DB through gateway,
-        // so cron never needs its own database connection.
-        if (url.startsWith("/api/internal/cron/") && configRepo) {
-            const cronPath = url.replace("/api/internal/cron/", "").split("?")[0];
-            const fullUrl = new URL(req.url, `http://${req.headers.host}`);
-            // POST endpoints
-            if (method === "POST") {
-                let body = "";
-                req.on("data", (chunk) => { body += chunk.toString(); });
-                req.on("end", async () => {
-                    try {
-                        const data = body ? JSON.parse(body) : {};
-                        if (cronPath === "register") {
-                            await configRepo.registerCronInstance(data.instanceId, data.endpoint);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ status: "ok" }));
-                            return;
-                        }
-                        if (cronPath === "heartbeat") {
-                            await configRepo.updateHeartbeat(data.instanceId, data.jobCount);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ status: "ok" }));
-                            return;
-                        }
-                        if (cronPath === "delete-instance") {
-                            await configRepo.deleteInstance(data.instanceId);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ status: "ok" }));
-                            return;
-                        }
-                        if (cronPath === "release-jobs") {
-                            await configRepo.releaseInstanceJobs(data.instanceId);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ status: "ok" }));
-                            return;
-                        }
-                        if (cronPath === "claim-job") {
-                            const claimed = await configRepo.claimUnassignedJob(data.jobId, data.instanceId);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ claimed }));
-                            return;
-                        }
-                        if (cronPath === "job-run") {
-                            await configRepo.updateCronJobRun(data.jobId, data.result);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ status: "ok" }));
-                            return;
-                        }
-                        if (cronPath === "reassign-jobs") {
-                            await configRepo.reassignOrphanedJobs(data.fromInstanceId, data.toInstanceId);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ status: "ok" }));
-                            return;
-                        }
-                        res.writeHead(404, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ error: "Unknown cron POST endpoint" }));
-                    }
-                    catch (err) {
-                        console.error(`[gateway] cron/${cronPath} error:`, err);
-                        res.writeHead(500, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ error: "Internal server error" }));
-                    }
-                });
-                return;
-            }
-            // GET endpoints
-            if (method === "GET") {
-                (async () => {
-                    try {
-                        if (cronPath === "jobs") {
-                            const instanceId = fullUrl.searchParams.get("instanceId");
-                            const unassigned = fullUrl.searchParams.get("unassigned");
-                            if (instanceId) {
-                                const jobs = await configRepo.listCronJobsByInstance(instanceId);
-                                res.writeHead(200, { "Content-Type": "application/json" });
-                                res.end(JSON.stringify({ jobs }));
-                                return;
-                            }
-                            if (unassigned === "1") {
-                                const jobs = await configRepo.getUnassignedActiveJobs();
-                                res.writeHead(200, { "Content-Type": "application/json" });
-                                res.end(JSON.stringify({ jobs }));
-                                return;
-                            }
-                            res.writeHead(400, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ error: "instanceId or unassigned=1 required" }));
-                            return;
-                        }
-                        // GET /api/internal/cron/jobs/:id
-                        if (cronPath.startsWith("jobs/")) {
-                            const jobId = cronPath.slice("jobs/".length);
-                            const job = await configRepo.getCronJobById(jobId);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ job }));
-                            return;
-                        }
-                        if (cronPath === "dead-instances") {
-                            const thresholdMs = parseInt(fullUrl.searchParams.get("thresholdMs") || "90000", 10);
-                            const instances = await configRepo.getDeadInstances(thresholdMs);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ instances }));
-                            return;
-                        }
-                        if (cronPath === "least-loaded") {
-                            const thresholdMs = parseInt(fullUrl.searchParams.get("thresholdMs") || "90000", 10);
-                            const instance = await configRepo.getLeastLoadedInstance(thresholdMs);
-                            res.writeHead(200, { "Content-Type": "application/json" });
-                            res.end(JSON.stringify({ instance }));
-                            return;
-                        }
-                        res.writeHead(404, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ error: "Unknown cron GET endpoint" }));
-                    }
-                    catch (err) {
-                        console.error(`[gateway] cron/${cronPath} error:`, err);
-                        res.writeHead(500, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ error: "Internal server error" }));
-                    }
-                })();
-                return;
-            }
-        }
-        // Internal cron notification endpoint: POST /api/internal/cron-notify
-        if (url === "/api/internal/cron-notify" && method === "POST") {
-            let body = "";
-            req.on("data", (chunk) => { body += chunk.toString(); });
-            req.on("end", async () => {
-                try {
-                    const data = JSON.parse(body);
-                    // 1. Write notification to DB
-                    if (db) {
-                        const notifRepo = new NotificationRepository(db);
-                        const notifId = await notifRepo.create({
-                            userId: data.userId,
-                            type: "cron_result",
-                            title: data.jobName,
-                            message: data.result === "success" ? data.resultText : (data.error || "Unknown error"),
-                            relatedId: data.jobId,
-                        });
-                        // 2. Push via WebSocket
-                        sendToUser(data.userId, "notification", {
-                            id: notifId,
-                            type: "cron_result",
-                            title: data.jobName,
-                            message: data.result === "success" ? data.resultText : (data.error || "Unknown error"),
-                            result: data.result,
-                            relatedId: data.jobId,
-                        });
-                    }
-                    // 3. Delegate to channel push via callback
-                    if (gatewayServer.onCronNotify) {
-                        gatewayServer.onCronNotify(data);
-                    }
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ status: "ok" }));
-                }
-                catch (err) {
-                    console.error("[gateway] cron-notify error:", err);
-                    res.writeHead(500, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Internal server error" }));
-                }
-            });
-            return;
-        }
         // Internal agent-prompt endpoint: POST /api/internal/agent-prompt
         // Synchronous execution — waits for agent to finish and returns result text.
         // Used by cron, triggers, and other internal callers.
@@ -629,6 +535,8 @@ export async function startGateway(opts) {
             req.on("end", async () => {
                 const startTime = Date.now();
                 let userId = "";
+                let client = null;
+                let sessionId;
                 try {
                     const data = JSON.parse(body);
                     userId = data.userId;
@@ -641,22 +549,76 @@ export async function startGateway(opts) {
                     }
                     console.log(`[gateway] agent-prompt from=${caller} user=${userId} session=${data.sessionId}`);
                     // 1. Get or create user's AgentBox (resolve real workspace ID from DB)
-                    const wsId = internalWorkspaceRepo
-                        ? (await internalWorkspaceRepo.getOrCreateDefault(userId)).id
-                        : "default";
+                    if (!data.workspaceId && !internalWorkspaceRepo)
+                        throw new Error("Database not available");
+                    const workspace = data.workspaceId
+                        ? await internalWorkspaceRepo?.getById(data.workspaceId) ?? null
+                        : await internalWorkspaceRepo.getOrCreateDefault(userId);
+                    const wsId = workspace?.id || data.workspaceId;
+                    const isDefaultWs = workspace?.isDefault ?? true;
                     const handle = await agentBoxManager.getOrCreate(userId, wsId);
-                    const client = new AgentBoxClient(handle.endpoint);
-                    // 2. Send prompt
-                    const promptResult = await client.prompt({ sessionId: data.sessionId, text: data.text });
-                    // 3. Wait for completion with timeout
-                    const resultText = await Promise.race([
-                        waitForAgentCompletion(client, promptResult.sessionId),
-                        rejectAfterTimeout(timeoutMs, data.sessionId),
-                    ]);
-                    const durationMs = Date.now() - startTime;
-                    console.log(`[gateway] agent-prompt completed user=${userId} duration=${durationMs}ms resultLen=${resultText.length}`);
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ status: "success", resultText, durationMs }));
+                    client = new AgentBoxClient(handle.endpoint, 30000, agentBoxTlsOptions);
+                    // 2. Build credential payload so AgentBox has kubeconfig etc.
+                    const credentials = await buildCredentialPayload(userId, wsId, isDefaultWs).catch((err) => {
+                        console.warn(`[gateway] agent-prompt credential build failed:`, err instanceof Error ? err.message : err);
+                        return undefined;
+                    });
+                    // 3. Resolve model config (workspace default → global default)
+                    let modelProvider;
+                    let modelId;
+                    let modelConfig;
+                    if (db) {
+                        const mcRepo = new ModelConfigRepository(db);
+                        // Try workspace default model first, then global default
+                        const wsDefault = workspace?.configJson?.defaultModel;
+                        const defaultModel = wsDefault?.provider && wsDefault?.modelId
+                            ? { provider: wsDefault.provider, modelId: wsDefault.modelId }
+                            : await mcRepo.getDefault();
+                        if (defaultModel) {
+                            modelProvider = defaultModel.provider;
+                            modelId = defaultModel.modelId;
+                            try {
+                                const providerConfig = await mcRepo.getProviderWithModels(modelProvider);
+                                if (providerConfig)
+                                    modelConfig = providerConfig;
+                            }
+                            catch (err) {
+                                console.warn(`[gateway] agent-prompt provider config resolve failed:`, err instanceof Error ? err.message : err);
+                            }
+                        }
+                    }
+                    // 4. Send prompt with credentials and model config
+                    const promptResult = await client.prompt({ sessionId: data.sessionId, text: data.text, credentials, modelProvider, modelId, modelConfig });
+                    sessionId = promptResult.sessionId;
+                    // 4. Wait for completion with cancellable timeout
+                    const timeout = rejectAfterTimeout(timeoutMs, data.sessionId);
+                    try {
+                        const resultText = await Promise.race([
+                            waitForAgentCompletion(client, promptResult.sessionId),
+                            timeout.promise,
+                        ]);
+                        timeout.cancel();
+                        const durationMs = Date.now() - startTime;
+                        console.log(`[gateway] agent-prompt completed user=${userId} duration=${durationMs}ms resultLen=${resultText.length}`);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ status: "success", resultText, durationMs }));
+                    }
+                    catch (innerErr) {
+                        timeout.cancel();
+                        // On timeout, attempt to abort + close the orphaned agent session
+                        if (client && sessionId && innerErr instanceof ExecutionTimeoutError) {
+                            try {
+                                await client.abortSession(sessionId);
+                            }
+                            catch { /* best-effort */ }
+                            try {
+                                await client.closeSession(sessionId);
+                            }
+                            catch { /* best-effort */ }
+                            console.log(`[gateway] agent-prompt session=${sessionId} aborted after timeout`);
+                        }
+                        throw innerErr;
+                    }
                 }
                 catch (err) {
                     const durationMs = Date.now() - startTime;
@@ -720,6 +682,42 @@ export async function startGateway(opts) {
             });
             return;
         }
+        // Internal session/stats purge endpoint: POST /api/internal/sessions/purge
+        if (url === "/api/internal/sessions/purge" && method === "POST") {
+            if (!db) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Database not available" }));
+                return;
+            }
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { softDeleteInactiveDays = 180, statsRetentionDays = 90, hardDeleteAfterDays = 30, } = body ? JSON.parse(body) : {};
+                    if (softDeleteInactiveDays < 1 || statsRetentionDays < 1 || hardDeleteAfterDays < 1) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Retention days must be >= 1" }));
+                        return;
+                    }
+                    const chatRepo = new ChatRepository(db);
+                    // Step 1: soft-delete inactive sessions
+                    const softDeleted = await chatRepo.softDeleteInactiveSessions(softDeleteInactiveDays);
+                    // Step 2: hard-delete old session_stats
+                    const statsPurged = await chatRepo.purgeOldSessionStats(statsRetentionDays);
+                    // Step 3: hard-delete soft-deleted sessions (messages cascade)
+                    const sessionsPurged = await chatRepo.purgeDeletedSessions(hardDeleteAfterDays);
+                    console.log(`[gateway] Session purge: softDeleted=${softDeleted}, statsPurged=${statsPurged}, sessionsPurged=${sessionsPurged}`);
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ status: "ok", softDeleted, statsPurged, sessionsPurged }));
+                }
+                catch (err) {
+                    console.error("[gateway] sessions/purge error:", err);
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Internal server error" }));
+                }
+            });
+            return;
+        }
         // Webhook endpoint: POST /hooks/v1/:triggerId
         if (url.startsWith("/hooks/v1/") && method === "POST") {
             const triggerId = url.split("/hooks/v1/")[1]?.split("?")[0];
@@ -788,7 +786,7 @@ export async function startGateway(opts) {
             }
         }
         // Serve static web UI
-        serveStatic(res, url);
+        serveStatic(res, url, cachedFrameSrc);
     });
     // WebSocket server
     const wss = new WebSocketServer({ noServer: true });
@@ -827,6 +825,7 @@ export async function startGateway(opts) {
     wss.on("connection", (ws, auth) => {
         clients.add(ws);
         aliveClients.add(ws);
+        emitDiagnostic({ type: "ws_connected" });
         ws.on("pong", () => aliveClients.add(ws));
         const authWs = ws;
         const authInfo = auth ? `user=${auth.username}` : "anonymous";
@@ -882,10 +881,13 @@ export async function startGateway(opts) {
                     }
                 }
             }
+            emitDiagnostic({ type: "ws_disconnected" });
             console.log(`[gateway] WS client disconnected (total: ${clients.size})`);
         });
         ws.on("error", (err) => {
             console.error("[gateway] WS error:", err.message);
+            // Note: do NOT emit ws_disconnected here — the "close" event always
+            // fires after "error" and handles the decrement + cleanup.
             clients.delete(ws);
         });
     });
@@ -897,6 +899,9 @@ export async function startGateway(opts) {
         console.log(`[gateway] Listening on http://${config.host}:${config.port}`);
         console.log(`[gateway] Web UI: http://${config.host}:${config.port}/`);
         console.log(`[gateway] WebSocket: ws://${config.host}:${config.port}/ws`);
+        if (!cachedMetricsToken && !process.env.SICLAW_METRICS_TOKEN) {
+            console.warn(`[gateway] WARNING: metrics token is not configured — /metrics endpoint is unauthenticated`);
+        }
     });
     // HTTPS server for internal mTLS API (AgentBox connections)
     const internalPort = config.internalPort || 3002;
@@ -927,6 +932,23 @@ export async function startGateway(opts) {
                         try {
                             const modelConfigRepo = new ModelConfigRepository(db);
                             const settings = await modelConfigRepo.exportSettingsConfig();
+                            // Append debugImage if configured via env
+                            if (process.env.SICLAW_DEBUG_IMAGE) {
+                                settings.debugImage = process.env.SICLAW_DEBUG_IMAGE;
+                            }
+                            // Append metrics config from system_config table
+                            if (sysConfigRepo) {
+                                const metricsPort = await sysConfigRepo.get("metrics.port");
+                                const metricsToken = await sysConfigRepo.get("metrics.token");
+                                const includeUserId = await sysConfigRepo.get("metrics.includeUserId");
+                                if (metricsPort || metricsToken || includeUserId) {
+                                    settings.metrics = {
+                                        ...(metricsPort ? { port: parseInt(metricsPort, 10) } : {}),
+                                        ...(metricsToken ? { token: metricsToken } : {}),
+                                        ...(includeUserId ? { includeUserId: includeUserId === "true" } : {}),
+                                    };
+                                }
+                            }
                             res.writeHead(200, { "Content-Type": "application/json" });
                             res.end(JSON.stringify(settings));
                         }
@@ -954,27 +976,16 @@ export async function startGateway(opts) {
                                 res.end(JSON.stringify({ error: "Client certificate required" }));
                                 return;
                             }
-                            // Parse userId from query params
+                            // Use userId from mTLS certificate identity (authoritative)
                             const urlObj = new URL(url, `https://${req.headers.host}`);
-                            const requestedUserId = urlObj.searchParams.get("userId");
-                            if (!requestedUserId) {
-                                res.writeHead(400, { "Content-Type": "application/json" });
-                                res.end(JSON.stringify({ error: "Missing userId parameter" }));
-                                return;
-                            }
-                            // Authorization: certificate userId must match requested userId
-                            if (identity.userId !== requestedUserId) {
-                                console.warn(`[gateway] cron-list authorization failed: cert userId=${identity.userId} requested=${requestedUserId}`);
-                                res.writeHead(403, { "Content-Type": "application/json" });
-                                res.end(JSON.stringify({ error: "Forbidden: userId mismatch" }));
-                                return;
-                            }
+                            const userId = identity.userId;
                             // Query cron jobs using ConfigRepository
                             const configRepo = new ConfigRepository(db);
-                            const jobs = await configRepo.listCronJobs(requestedUserId);
+                            const workspaceId = urlObj.searchParams.get("workspaceId") || identity.workspaceId;
+                            const jobs = await configRepo.listCronJobs(userId, workspaceId ? { workspaceId } : undefined);
                             res.writeHead(200, { "Content-Type": "application/json" });
                             res.end(JSON.stringify({ jobs }));
-                            console.log(`[gateway] Listed ${jobs.length} cron jobs for userId=${requestedUserId}`);
+                            console.log(`[gateway] Listed ${jobs.length} cron jobs for userId=${userId}${workspaceId ? ` workspaceId=${workspaceId}` : ""}`);
                         }
                         catch (err) {
                             console.error("[gateway] cron-list error:", err);
@@ -1013,7 +1024,10 @@ export async function startGateway(opts) {
                 if (url === "/api/internal/mcp-servers" && method === "GET") {
                     (async () => {
                         try {
-                            const localConfig = loadMcpServersConfig(undefined, { localOnly: true });
+                            const config = loadConfig();
+                            const localConfig = Object.keys(config.mcpServers).length > 0
+                                ? { mcpServers: config.mcpServers }
+                                : null;
                             const mcpRepo = db ? new McpServerRepository(db) : null;
                             const merged = await buildMergedMcpConfig(localConfig, mcpRepo);
                             res.writeHead(200, { "Content-Type": "application/json" });
@@ -1051,8 +1065,11 @@ export async function startGateway(opts) {
         bindCodeStore,
         db,
         rpcMethods,
+        cronService,
         buildCredentialPayload,
+        agentBoxTlsOptions,
         async close() {
+            cronService?.stop();
             bindCodeStore.dispose();
             await agentBoxManager.cleanup();
             for (const ws of clients) {
@@ -1072,33 +1089,70 @@ export async function startGateway(opts) {
 /** Consume SSE stream from AgentBox and extract final assistant text */
 async function waitForAgentCompletion(client, sessionId) {
     let resultText = "";
+    // Accumulate text deltas per message (claude-sdk brain emits text via
+    // message_update/text_delta and sends empty content in message_end)
+    let currentMsgText = "";
     for await (const event of client.streamEvents(sessionId)) {
         const evt = event;
+        // Accumulate streaming text deltas
+        if (evt.type === "message_update") {
+            const ame = evt.assistantMessageEvent;
+            if (ame?.type === "text_delta" && typeof ame.delta === "string") {
+                currentMsgText += ame.delta;
+            }
+        }
+        if (evt.type === "message_start") {
+            // New message — reset accumulated text
+            currentMsgText = "";
+        }
         if (evt.type === "message_end" || evt.type === "turn_end") {
             const message = evt.message;
             if (message?.role === "assistant") {
+                // Try to extract from message.content first (pi-agent brain)
+                let extracted = "";
                 const content = message.content;
-                if (typeof content === "string") {
-                    resultText = content;
+                if (typeof content === "string" && content) {
+                    extracted = content;
                 }
                 else if (Array.isArray(content)) {
-                    const text = content
+                    extracted = content
                         .filter((c) => c.type === "text")
                         .map((c) => c.text ?? "")
                         .join("");
-                    if (text)
-                        resultText = text;
                 }
+                // Use extracted content, or fall back to accumulated text deltas
+                // (claude-sdk brain sends empty content in message_end)
+                resultText = extracted || currentMsgText || resultText;
             }
+            currentMsgText = "";
         }
         if (evt.type === "agent_end")
             break;
     }
+    // Final fallback: if no message_end was captured but we have accumulated text
+    if (!resultText && currentMsgText) {
+        resultText = currentMsgText;
+    }
     return resultText;
 }
-/** Returns a promise that rejects after the given timeout */
+class ExecutionTimeoutError extends Error {
+    constructor(sessionId, ms) {
+        super(`agent-prompt session=${sessionId} timed out after ${ms / 1000}s`);
+        this.name = "ExecutionTimeoutError";
+    }
+}
+/** Returns a cancellable promise that rejects after the given timeout */
 function rejectAfterTimeout(ms, sessionId) {
-    return new Promise((_, reject) => setTimeout(() => reject(new Error(`agent-prompt session=${sessionId} timed out after ${ms / 1000}s`)), ms));
+    let timer;
+    const promise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new ExecutionTimeoutError(sessionId, ms)), ms);
+        timer.unref();
+    });
+    return {
+        promise,
+        cancel: () => { if (timer)
+            clearTimeout(timer); },
+    };
 }
 /**
  * Resolve JWT secret: env var > DB > generate new and persist to DB.
@@ -1125,22 +1179,4 @@ async function resolveJwtSecret(sysConfigRepo) {
     }
     return generated;
 }
-/**
- * Resolve an API key value — if it looks like an env var name (no slashes,
- * no dots, all uppercase/underscores), resolve it from process.env.
- */
-function resolveApiKey(value) {
-    // Legacy: bare ALL_CAPS_NAME treated as env var name
-    if (/^[A-Z_][A-Z0-9_]*$/.test(value)) {
-        return process.env[value] ?? value;
-    }
-    // $VAR / ${VAR} syntax — inline env-var references
-    if (/\$\{[A-Za-z_][A-Za-z0-9_]*\}|\$[A-Za-z_][A-Za-z0-9_]*/.test(value)) {
-        return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, bare) => {
-            const name = braced || bare;
-            return process.env[name] ?? "";
-        });
-    }
-    return value;
-}
 //# sourceMappingURL=server.js.map