vibeoscore 1.0.2

package/lib/tdd.js

@@ -0,0 +1,218 @@
+function extractExports(sourceContent, ext) {
+  if (!sourceContent || typeof sourceContent !== "string") return []
+  const exports = []
+  const seen = new Set()
+  const add = (name, type = "function") => {
+    if (name && !seen.has(name)) { seen.add(name); exports.push({ name, type }) }
+  }
+
+  switch (ext) {
+    case "py": {
+      const defRe = /^def\s+([a-zA-Z_]\w*)\s*\(/gm
+      const classRe = /^class\s+([a-zA-Z_]\w*)/gm
+      let m
+      while ((m = defRe.exec(sourceContent)) !== null) add(m[1], "function")
+      while ((m = classRe.exec(sourceContent)) !== null) add(m[1], "class")
+      break
+    }
+    case "js": case "mjs": case "jsx": {
+      const funcRe = /^(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$]\w*)\s*\(/gm
+      const constRe = /^(?:export\s+)?const\s+([a-zA-Z_$]\w*)\s*[:=]\s*(?:async\s+)?(?:\(|function)/gm
+      let m
+      while ((m = funcRe.exec(sourceContent)) !== null) add(m[1], "function")
+      while ((m = constRe.exec(sourceContent)) !== null) add(m[1], "function")
+      break
+    }
+    case "ts": case "tsx": {
+      const funcRe = /^(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$]\w*)\s*\(/gm
+      const constRe = /^(?:export\s+)?const\s+([a-zA-Z_$]\w*)\s*[:=]\s*(?:async\s+)?(?:\(|function)/gm
+      const classRe = /^(?:export\s+)?class\s+([a-zA-Z_$]\w*)/gm
+      let m
+      while ((m = funcRe.exec(sourceContent)) !== null) add(m[1], "function")
+      while ((m = constRe.exec(sourceContent)) !== null) add(m[1], "function")
+      while ((m = classRe.exec(sourceContent)) !== null) add(m[1], "class")
+      break
+    }
+    case "go": {
+      const funcRe = /^func\s+(?:\([^)]+\)\s+)?([a-zA-Z_]\w*)\s*\(/gm
+      let m
+      while ((m = funcRe.exec(sourceContent)) !== null) add(m[1], "function")
+      break
+    }
+    case "rs": {
+      const fnRe = /^pub\s+(?:async\s+)?fn\s+([a-zA-Z_]\w*)\s*[<(]/gm
+      const structRe = /^pub\s+struct\s+([a-zA-Z_]\w*)/gm
+      let m
+      while ((m = fnRe.exec(sourceContent)) !== null) add(m[1], "function")
+      while ((m = structRe.exec(sourceContent)) !== null) add(m[1], "struct")
+      break
+    }
+    case "rb": {
+      const defRe = /^\s*def\s+(?:self\.)?([a-zA-Z_]\w*[!?=]?)/gm
+      const classRe = /^\s*class\s+([a-zA-Z_]\w*)/gm
+      let m
+      while ((m = defRe.exec(sourceContent)) !== null) add(m[1], "function")
+      while ((m = classRe.exec(sourceContent)) !== null) add(m[1], "class")
+      break
+    }
+    case "java": case "kt": {
+      const methodRe = /^\s*(?:public|protected|private|\s)+\s+(?:static\s+)?(?:final\s+)?\w+\s+([a-zA-Z_]\w*)\s*\(/gm
+      const funRe = /^\s*(?:fun)\s+([a-zA-Z_]\w*)\s*[<(]/gm
+      let m
+      while ((m = ext === "kt" ? funRe.exec(sourceContent) : methodRe.exec(sourceContent)) !== null) add(m[1], "function")
+      break
+    }
+    case "sh": {
+      const funcRe = /^(?:function\s+)?([a-zA-Z_]\w*)\s*\(\)/gm
+      let m
+      while ((m = funcRe.exec(sourceContent)) !== null) add(m[1], "function")
+      break
+    }
+  }
+  return exports
+}
+
+function inferFunctionParams(sourceContent, funcName) {
+  if (!sourceContent || !funcName) return []
+  const patterns = [
+    new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${escapeRegex(funcName)}\\s*\\(([^)]*)\\)`, "m"),
+    new RegExp(`(?:export\\s+)?const\\s+${escapeRegex(funcName)}\\s*[:=]\\s*(?:async\\s+)?\\(([^)]*)\\)`, "m"),
+    new RegExp(`def\\s+${escapeRegex(funcName)}\\s*\\(([^)]*)\\)`, "m"),
+    new RegExp(`func\\s+(?:\\([^)]+\\)\\s+)?${escapeRegex(funcName)}\\s*\\(([^)]*)\\)`, "m"),
+    new RegExp(`(?:pub\\s+)?fn\\s+${escapeRegex(funcName)}\\s*[<\\(]([^)]*)\\)`, "m"),
+  ]
+
+  for (const pat of patterns) {
+    const m = sourceContent.match(pat)
+    if (m) {
+      return m[1].split(",").map(s => {
+        const trimmed = s.trim()
+        if (!trimmed) return null
+        const parts = trimmed.split(":").map(p => p.split("="))
+        const name = parts[0][0]?.trim().replace(/^[*&]/, "")
+        const type = parts[0][1]?.trim() || inferTypeFromName(name, parts[0][0]?.split("=")[1]?.trim())
+        const defaultValue = parts[0][1]?.includes("=") ? parts[0][0].split("=")[1]?.trim() : (parts[1]?.join("=").trim())
+        return name ? { name, type: type || "any", defaultValue } : null
+      }).filter(Boolean)
+    }
+  }
+  return []
+}
+
+function inferTypeFromName(paramName, defaultValue) {
+  if (!paramName) return "any"
+  const name = paramName.toLowerCase()
+
+  if (defaultValue !== undefined) {
+    if (typeof defaultValue === "string") {
+      if (defaultValue === "true" || defaultValue === "false") return "boolean"
+      if (/^-?\d+(\.\d+)?$/.test(defaultValue)) return "number"
+      if (defaultValue.startsWith("[") || defaultValue.startsWith("{")) return defaultValue.startsWith("[") ? "array" : "object"
+      return "string"
+    }
+  }
+
+  if (/^(is|has|can|should|will|did|enable|disable|visible|active|open|closed)/.test(name)) return "boolean"
+  if (/^(count|index|limit|size|length|max|min|width|height|depth|offset|duration|delay|timeout|interval|rate|threshold|level|score|priority|version|port|year|month|day|hour|minute|second)/.test(name)) return "number"
+  if (/^(name|title|label|text|content|body|message|description|summary|path|url|uri|host|port|file|filename|ext|extension|format|type|kind|mode|state|status|color|theme|lang|language|locale|timezone|currency|unit|prefix|suffix|key|token|secret|password|email|phone|address|id|uuid|slug)/.test(name)) return "string"
+  if (/^(items|list|array|elements|nodes|children|options|params|args|arguments|values|entries|records|rows|columns|fields|properties|attrs|attributes|headers|tags|categories|labels|classes|styles)/.test(name)) return "array"
+  if (/^(obj|config|opts|options|settings|prefs|preferences|context|state|data|info|metadata|meta|props|query|filter|sort|pagination|page|request|response|event|error|result|output|input)/.test(name)) return "object"
+  if (/^(fn|cb|callback|handler|listener|middleware|transform|map|reduce|filter|sort|forEach)/.test(name)) return "function"
+
+  return "any"
+}
+
+function buildTestSkeleton(language, fileName, exports, options = {}) {
+  const { strict = true, quality = true } = options
+  const testName = fileName.replace(/\.[^.]+$/, "")
+
+  const skeletons = {
+    py: () => {
+      const imports = `import unittest\nfrom ${testName} import ${exports.map(e => e.name).join(", ")}\n`
+      const tests = exports.map(exp => {
+        if (exp.type === "class") {
+          return `\nclass Test${exp.name}(unittest.TestCase):\n    def test_init(self):\n        """Test ${exp.name} initialization."""\n        instance = ${exp.name}()\n        self.assertIsNotNone(instance)\n`
+        }
+        const params = inferFunctionParams("", exp.name)
+        const paramStr = params.map(p => p.defaultValue !== undefined ? `${p.name}=${p.defaultValue}` : "None").join(", ") || ""
+        return `\n    def test_${exp.name}_smoke(self):\n        """Smoke test for ${exp.name}."""\n        result = ${exp.name}(${paramStr})\n        ${strict ? "self.assertIsNotNone(result)" : "pass"}\n`
+      }).join("")
+      return `${imports}\n${tests}`
+    },
+
+    js: () => {
+      const imports = `const { ${exports.map(e => e.name).join(", ")} } = require("./${testName}")\n`
+      const tests = exports.map(exp => {
+        const params = inferFunctionParams("", exp.name)
+        const paramStr = params.map(p => p.defaultValue !== undefined ? `${p.name}=${p.defaultValue}` : "undefined").join(", ") || ""
+        return `\ntest("${exp.name} smoke test", () => {\n  const result = ${exp.name}(${paramStr})\n  ${strict ? "expect(result).toBeDefined()" : "// TODO: add assertions"}\n})`
+      }).join("\n")
+      return `${imports}\n${tests}`
+    },
+
+    ts: () => {
+      const imports = `import { ${exports.map(e => e.name).join(", ")} } from "./${testName}"\n`
+      const tests = exports.map(exp => {
+        const params = inferFunctionParams("", exp.name)
+        const paramStr = params.map(p => p.defaultValue !== undefined ? `${p.name}=${p.defaultValue}` : "undefined").join(", ") || ""
+        return `\ntest("${exp.name} smoke test", () => {\n  const result = ${exp.name}(${paramStr})\n  ${strict ? "expect(result).toBeDefined()" : "// TODO: add assertions"}\n})`
+      }).join("\n")
+      return `${imports}\n${tests}`
+    },
+
+    go: () => {
+      const tests = exports.map(exp => {
+        return `\nfunc Test${capitalize(exp.name)}(t *testing.T) {\n\t// TODO: implement test for ${exp.name}\n\tt.Skip("not implemented")\n}`
+      }).join("\n")
+      return `package main\n\nimport "testing"\n${tests}`
+    },
+
+    sh: () => {
+      const tests = exports.map(exp => {
+        return `\ntest_${exp.name}() {\n  # TODO: implement test for ${exp.name}\n  echo "SKIP: test_${exp.name} not implemented"\n}`
+      }).join("\n")
+      return `#!/usr/bin/env bash\nset -euo pipefail\n\nsource "./${testName}.sh"\n${tests}`
+    },
+
+    rs: () => {
+      const tests = exports.map(exp => {
+        return `\n#[test]\nfn test_${exp.name}() {\n    // TODO: implement test for ${exp.name}\n}`
+      }).join("\n")
+      return `#[cfg(test)]\nmod tests {\n    use super::*;\n${tests}\n}`
+    },
+
+    rb: () => {
+      const tests = exports.map(exp => {
+        return `\n  def test_${exp.name}\n    # TODO: implement test for ${exp.name}\n    skip "not implemented"\n  end`
+      }).join("\n")
+      return `require "minitest/autorun"\nrequire_relative "${testName}"\n\nclass Test${capitalize(testName)} < Minitest::Test\n${tests}\nend`
+    },
+
+    java: () => {
+      const tests = exports.map(exp => {
+        return `\n    @Test\n    void test${capitalize(exp.name)}() {\n        // TODO: implement test for ${exp.name}\n    }`
+      }).join("\n")
+      return `import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass ${capitalize(testName)}Test {\n${tests}\n}`
+    },
+
+    kt: () => {
+      const tests = exports.map(exp => {
+        return `\n    @Test\n    fun test${capitalize(exp.name)}() {\n        // TODO: implement test for ${exp.name}\n    }`
+      }).join("\n")
+      return `import org.junit.jupiter.api.Test\nimport org.junit.jupiter.api.Assertions.*\n\nclass ${capitalize(testName)}Test {\n${tests}\n}`
+    },
+  }
+
+  const generator = skeletons[language] || skeletons.js
+  return generator()
+}
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+export { extractExports, inferFunctionParams, inferTypeFromName, buildTestSkeleton }

package/lib/tier-routing.js

@@ -0,0 +1,48 @@
+const FALLBACK_HIGH = /opus|gemini-.*-pro|deepseek\/deepseek-v4-pro|gpt-5|(^|\/)o[134]($|-|\/)/i
+const FALLBACK_MID = /deepseek\/deepseek-v4-flash|claude.*sonnet|gemini-.*-flash|gpt-4o(?!-mini)/i
+
+const BASE_EXPLORATORY = new Set([
+  "check", "find", "list", "search", "does", "verify", "look", "count",
+  "show", "get", "read", "grep", "scan", "detect", "inspect"
+])
+
+function classify(model, customRegex = null) {
+  const s = String(model || "").toLowerCase()
+  const highRe = customRegex?.high ? new RegExp(customRegex.high, "i") : FALLBACK_HIGH
+  const midRe = customRegex?.mid ? new RegExp(customRegex.mid, "i") : FALLBACK_MID
+  if (highRe.test(s)) return "high"
+  if (midRe.test(s)) return "mid"
+  return "budget"
+}
+
+function routeModel(prompt, currentTier, trinityCheap, trinityMedium, learnedExploratory = [], stressScore = 0) {
+  const firstWord = prompt.split(/\s+/)[0]?.toLowerCase() || ""
+
+  const exploratory = new Set([...BASE_EXPLORATORY, ...(learnedExploratory || [])])
+  const isExploratory = exploratory.has(firstWord)
+
+  if (isExploratory && trinityCheap) {
+    return { target: trinityCheap, reason: "exploratory_first_word", word: firstWord }
+  }
+
+  if (currentTier === "high" && trinityMedium) {
+    let target = trinityMedium
+
+    if (trinityCheap && stressScore > 0.5) {
+      target = trinityCheap
+      return { target, reason: "stress_aware_downgrade", stress_score: stressScore }
+    }
+
+    return { target, reason: "medium_fallback" }
+  }
+
+  return { target: trinityCheap || null, reason: "default_cheap" }
+}
+
+function isExploratoryPrompt(prompt, learnedExploratory = []) {
+  const firstWord = prompt.split(/\s+/)[0]?.toLowerCase() || ""
+  const exploratory = new Set([...BASE_EXPLORATORY, ...(learnedExploratory || [])])
+  return { is_exploratory: exploratory.has(firstWord), first_word: firstWord }
+}
+
+export { classify, routeModel, isExploratoryPrompt, BASE_EXPLORATORY }

package/mcp-server.js

@@ -0,0 +1,370 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 vibeOS <https://github.com/DrunkkToys/vibeOS>
+import http from "node:http";
+import { parse as parseUrl } from "node:url";
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { extname, join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const MIME_MAP = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+};
+function json(res, statusCode, data) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let raw = "";
+        req.on("data", (chunk) => {
+            raw += String(chunk || "");
+            if (raw.length > 1024 * 1024) {
+                reject(new Error("payload too large"));
+            }
+        });
+        req.on("end", () => {
+            if (!raw.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("invalid request"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+const _MCP_FILENAME = fileURLToPath(import.meta.url);
+const _MCP_DIR = dirname(_MCP_FILENAME);
+function resolveDashboardDir() {
+    const c = [
+        join(_MCP_DIR, "dashboard", "dist"),
+    ];
+    for (const p of c) {
+        if (existsSync(join(p, "index.html")))
+            return p;
+    }
+    return c[0];
+}
+const DASHBOARD_DIR = resolveDashboardDir();
+
+const BACKEND_HEALTH_URL = process.env.VIBEOS_BACKEND_HEALTH_URL || "http://127.0.0.1:3000/health"
+const BACKEND_HEALTH_TTL_MS = 5_000
+
+let backendHealth = { ok: null, checkedAt: 0 }
+
+async function probeBackendHealth(force = false) {
+  const now = Date.now()
+  if (!force && backendHealth.ok !== null && (now - backendHealth.checkedAt) < BACKEND_HEALTH_TTL_MS) {
+    return backendHealth.ok
+  }
+  try {
+    const ctl = new AbortController()
+    const timer = setTimeout(() => ctl.abort(), 1500)
+    const res = await fetch(BACKEND_HEALTH_URL, { signal: ctl.signal })
+    clearTimeout(timer)
+    backendHealth = { ok: res.ok, checkedAt: now }
+    return res.ok
+  } catch {
+    backendHealth = { ok: false, checkedAt: now }
+    return false
+  }
+}
+
+function sendFile(res, fp) {
+    if (!existsSync(fp)) {
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("not found");
+        return;
+    }
+    const ext = extname(fp).toLowerCase();
+    const mime = MIME_MAP[ext] || "application/octet-stream";
+    const st = statSync(fp);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", mime);
+    res.setHeader("Content-Length", st.size);
+    res.setHeader("Cache-Control", "no-cache");
+    const s = createReadStream(fp);
+    s.pipe(res);
+    s.on("error", () => { res.statusCode = 500; res.end(); });
+}
+function serveDashboard(res, p) {
+    const idx = join(DASHBOARD_DIR, "index.html");
+    let fp = join(DASHBOARD_DIR, p === "/" ? "index.html" : p);
+    if (existsSync(fp) && statSync(fp).isFile()) {
+        sendFile(res, fp);
+        return;
+    }
+    if (existsSync(idx)) {
+        sendFile(res, idx);
+        return;
+    }
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("not found");
+}
+export function createMcpServer(deps) {
+    let server = null;
+    let startPromise = null;
+    let closePromise = null;
+    const handler = async (req, res) => {
+        try {
+            const method = (req.method || "GET").toUpperCase();
+            const parsed = parseUrl(req.url || "/", true);
+            const path = parsed.pathname || "/";
+            if (method === "GET" && path === "/status") {
+                const state = deps.getState()
+                const ok = await probeBackendHealth()
+                json(res, 200, { ...state, backend_connected: ok === true, backend_health_url: BACKEND_HEALTH_URL })
+                return;
+            }
+            if (method === "GET" && path === "/savings") {
+                json(res, 200, deps.getSavings());
+                return;
+            }
+            if (method === "GET" && path === "/sessions") {
+                const state = deps.getState();
+                const sessionsMap = state?.sessions_raw || {};
+                const sessions = Object.entries(sessionsMap).map(([id, ses]) => ({
+                    id,
+                    started: ses?.started || null,
+                    cost_usd: Number(ses?.cost_usd ?? 0) || 0,
+                    delegation_savings_usd: Array.isArray(ses?.warns)
+                        ? ses.warns.reduce((sum, w) => sum + (Number(w?.est_savings_usd ?? 0) || 0), 0)
+                        : ses?.total_savings_usd || 0,
+                    cache_savings_usd: Number(ses?.cache_savings_usd ?? 0) || 0,
+                    warns_count: Array.isArray(ses?.warns) ? ses.warns.length : 0,
+                }));
+                json(res, 200, { sessions, total_sessions: sessions.length });
+                return;
+            }
+            if (method === "GET" && path === "/sessions/current") {
+                json(res, 200, deps.getSessionMetrics(deps.getCurrentSessionId()));
+                return;
+            }
+            if (method === "GET" && path === "/reports") {
+                try {
+                    const query = parsed.query;
+                    const type = typeof query.type === "string" ? query.type : undefined;
+                    const project = typeof query.project === "string" ? query.project : undefined;
+                    const hoursRaw = query.hours;
+                    const hours = hoursRaw != null ? Number(hoursRaw) : undefined;
+                    const fingerprint = typeof query.fingerprint === "string" ? query.fingerprint : undefined;
+                    const reports = deps.listReports({ type, project, hours: Number.isFinite(hours) ? hours : undefined, fingerprint });
+                    json(res, 200, reports);
+                }
+                catch (err) {
+                    const error = err;
+                    if (error?.status === 404) {
+                        json(res, 404, { error: "not found", status: 404 });
+                        return;
+                    }
+                    throw err;
+                }
+                return;
+            }
+            if (method === "GET" && path.startsWith("/reports/")) {
+                const id = decodeURIComponent(path.replace(/^\/reports\//, "")).trim();
+                const report = deps.readReport(id);
+                if (!report) {
+                    json(res, 404, { error: "not found", status: 404 });
+                    return;
+                }
+                json(res, 200, report);
+                return;
+            }
+            if (method === "GET" && path === "/diagnose") {
+                json(res, 200, deps.runDiagnose());
+                return;
+            }
+            if (method === "GET" && path === "/project") {
+                json(res, 200, deps.runProject());
+                return;
+            }
+            if (method === "POST" && path === "/trinity") {
+                let body;
+                try {
+                    body = await parseBody(req);
+                }
+                catch {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const action = body?.action;
+                const slot = body?.slot;
+                const level = body?.level;
+                if (!action || typeof action !== "string") {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const result = await deps.runTrinity(action, { slot, level });
+                const txt = typeof result === "string" ? result : JSON.stringify(result);
+                const ok = !(txt.startsWith("❌") || txt.toLowerCase().includes("unknown action"));
+                json(res, ok ? 200 : 400, ok ? { ok: true, result } : { ok: false, error: txt });
+                return;
+            }
+            if (method === "POST" && path === "/research-audit") {
+                let body;
+                try {
+                    body = await parseBody(req);
+                }
+                catch {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const hours = Number(body?.hours ?? 24);
+                const report = deps.runResearchAudit(Number.isFinite(hours) ? hours : 24);
+                json(res, 200, report);
+                return;
+            }
+            if (method === "POST" && path === "/reports") {
+                let body;
+                try {
+                    body = await parseBody(req);
+                }
+                catch {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                if (!body || typeof body !== "object") {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const id = deps.saveReport({
+                    type: "manual",
+                    summary: body.summary || "",
+                    findings: body.findings || [],
+                    metrics: body.metrics || {},
+                    narrative: body.narrative || "",
+                    tags: Array.isArray(body.tags) ? body.tags : [],
+                });
+                if (!id) {
+                    json(res, 500, { error: "failed to save report", status: 500 });
+                    return;
+                }
+                json(res, 200, { ok: true, id });
+                return;
+            }
+            if (method === "POST" && path === "/sessions/checkout") {
+                const result = deps.generateSessionCheckout();
+                json(res, 200, result);
+                return;
+            }
+            if (method === "GET" && path === "/events") {
+                res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*" });
+                const push = async () => { const state = deps.getState(); const ok = await probeBackendHealth(); res.write(`data: ${JSON.stringify({ status: { ...state, backend_connected: ok === true, backend_health_url: BACKEND_HEALTH_URL }, savings: deps.getSavings() })}\n\n`); };
+                push();
+                const iv = setInterval(push, 1500);
+                req.on("close", () => { clearInterval(iv); });
+                return;
+            }
+            if (existsSync(join(DASHBOARD_DIR, "index.html"))) {
+                serveDashboard(res, path);
+                return;
+            }
+            json(res, 404, { error: "not found", status: 404 });
+        }
+        catch (err) {
+            const error = err;
+            json(res, 500, { error: error?.message || "internal error", status: 500 });
+        }
+    };
+    return {
+        async start(port) {
+            if (closePromise)
+                await closePromise;
+            if (server)
+                return server;
+            if (startPromise)
+                return startPromise;
+            const listen = (listenPort) => new Promise((resolve, reject) => {
+                const nextServer = http.createServer((req, res) => {
+                    void handler(req, res);
+                });
+                const onListening = () => resolve(nextServer);
+                const onError = (err) => {
+                    try {
+                        nextServer.close();
+                    }
+                    catch { }
+                    reject(err);
+                };
+                nextServer.once("listening", onListening);
+                nextServer.once("error", onError);
+                try {
+                    nextServer.listen(listenPort, "127.0.0.1");
+                }
+                catch (err) {
+                    onError(err);
+                }
+            });
+            startPromise = (async () => {
+                try {
+                    server = await listen(port);
+                    return server;
+                }
+                catch (err) {
+                    const error = err;
+                    if (error?.code !== "EADDRINUSE" || port === 0) {
+                        startPromise = null;
+                        server = null;
+                        console.error(`[vibeOS] MCP server bind failed: ${error.message}`);
+                        throw err;
+                    }
+                    try {
+                        const fallback = await listen(0);
+                        server = fallback;
+                        const bound = fallback.address();
+                        const actualPort = typeof bound === "object" && bound ? bound.port : 0;
+                        console.error(`[vibeOS] MCP server port ${port} busy; fell back to ${actualPort}`);
+                        return fallback;
+                    }
+                    catch (fallbackErr) {
+                        const fbError = fallbackErr;
+                        startPromise = null;
+                        server = null;
+                        console.error(`[vibeOS] MCP server bind failed: ${fbError.message}`);
+                        throw fallbackErr;
+                    }
+                }
+                finally {
+                    startPromise = null;
+                }
+            })();
+            return startPromise;
+        },
+        close() {
+            if (!server)
+                return closePromise || Promise.resolve();
+            if (closePromise)
+                return closePromise;
+            const current = server;
+            closePromise = new Promise((resolve) => {
+                try {
+                    current.close(() => {
+                        if (server === current)
+                            server = null;
+                        closePromise = null;
+                        resolve();
+                    });
+                }
+                catch {
+                    if (server === current)
+                        server = null;
+                    closePromise = null;
+                    resolve();
+                }
+            });
+            return closePromise;
+        },
+    };
+}