@vibecodetown/mcp-server 1.3.1

package/build/dashboard/autostart.js

@@ -0,0 +1,121 @@
+/**
+ * Dashboard Autostart
+ * ===================
+ *
+ * Singleton autostart module for local Dashboard server.
+ * Provides sync packet receiving and statistics API.
+ *
+ * Environment:
+ *   VIBE_DASHBOARD=1              - Enable Dashboard server
+ *   VIBE_DASHBOARD_PORT=8787      - Server port (default: 8787)
+ *   VIBE_DASHBOARD_HOST=127.0.0.1 - Server host
+ *   VIBE_DASHBOARD_DIR=<path>     - Storage directory
+ *   VIBE_CLOUD_SYNC_TOKEN=<token> - Auth token (optional)
+ *
+ * @module dashboard/autostart
+ */
+import { startDashboardServer } from "./server.js";
+// ============================================================
+// Singleton State
+// ============================================================
+let _handle = null;
+let _startPromise = null;
+// ============================================================
+// Environment Helpers
+// ============================================================
+/**
+ * Check if Dashboard server is enabled.
+ */
+export function isDashboardEnabled() {
+    return process.env.VIBE_DASHBOARD === "1";
+}
+// ============================================================
+// Autostart Functions
+// ============================================================
+/**
+ * Start Dashboard server if enabled via environment variable.
+ * Safe to call multiple times (singleton pattern).
+ *
+ * @returns Server handle if started, null if disabled or already running
+ */
+export async function startDashboardIfEnabled() {
+    // Return existing handle if already started
+    if (_handle) {
+        return _handle;
+    }
+    // Return existing promise if startup in progress
+    if (_startPromise) {
+        return _startPromise;
+    }
+    // Check if enabled
+    if (!isDashboardEnabled()) {
+        return null;
+    }
+    // Start with deduplication
+    _startPromise = (async () => {
+        try {
+            const host = process.env.VIBE_DASHBOARD_HOST ?? "127.0.0.1";
+            const port = parseInt(process.env.VIBE_DASHBOARD_PORT ?? "8787", 10);
+            const storageDir = process.env.VIBE_DASHBOARD_DIR;
+            const authToken = process.env.VIBE_CLOUD_SYNC_TOKEN ?? null;
+            _handle = startDashboardServer({
+                host,
+                port,
+                storageDir,
+                authToken,
+                secretKey: authToken,
+            });
+            console.error(`[Dashboard] Started on ${_handle.url}`);
+            return _handle;
+        }
+        catch (e) {
+            console.error(`[Dashboard] Failed to start: ${e instanceof Error ? e.message : String(e)}`);
+            return null;
+        }
+        finally {
+            _startPromise = null;
+        }
+    })();
+    return _startPromise;
+}
+/**
+ * Shutdown Dashboard server if running.
+ * Safe to call multiple times.
+ */
+export async function shutdownDashboard() {
+    // Wait for any pending startup
+    if (_startPromise) {
+        await _startPromise;
+    }
+    if (!_handle) {
+        return;
+    }
+    try {
+        await _handle.close();
+        console.error(`[Dashboard] Shutdown complete`);
+    }
+    catch (e) {
+        console.error(`[Dashboard] Shutdown error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    finally {
+        _handle = null;
+    }
+}
+/**
+ * Get the current server handle (if running).
+ */
+export function getDashboardHandle() {
+    return _handle;
+}
+/**
+ * Check if Dashboard server is currently running.
+ */
+export function isDashboardRunning() {
+    return _handle !== null;
+}
+/**
+ * Get the Dashboard server URL (if running).
+ */
+export function getDashboardUrl() {
+    return _handle?.url ?? null;
+}

package/build/dashboard/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Dashboard Module
+ * ================
+ *
+ * Local dashboard server for sync packet storage and statistics.
+ *
+ * Usage:
+ * ```ts
+ * import { startDashboardIfEnabled, shutdownDashboard } from './dashboard';
+ *
+ * // Auto-start if VIBE_DASHBOARD=1
+ * const handle = await startDashboardIfEnabled();
+ *
+ * // Manual cleanup
+ * await shutdownDashboard();
+ * ```
+ *
+ * @module dashboard
+ */
+export { startDashboardServer, type DashboardServerOptions, type DashboardServerHandle, } from "./server.js";
+export { startDashboardIfEnabled, shutdownDashboard, isDashboardEnabled, isDashboardRunning, getDashboardHandle, getDashboardUrl, } from "./autostart.js";

package/build/dashboard/index.js

@@ -0,0 +1,23 @@
+/**
+ * Dashboard Module
+ * ================
+ *
+ * Local dashboard server for sync packet storage and statistics.
+ *
+ * Usage:
+ * ```ts
+ * import { startDashboardIfEnabled, shutdownDashboard } from './dashboard';
+ *
+ * // Auto-start if VIBE_DASHBOARD=1
+ * const handle = await startDashboardIfEnabled();
+ *
+ * // Manual cleanup
+ * await shutdownDashboard();
+ * ```
+ *
+ * @module dashboard
+ */
+// Server
+export { startDashboardServer, } from "./server.js";
+// Autostart
+export { startDashboardIfEnabled, shutdownDashboard, isDashboardEnabled, isDashboardRunning, getDashboardHandle, getDashboardUrl, } from "./autostart.js";

package/build/dashboard/server.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Local Dashboard Server (MVP)
+ *
+ * 목표:
+ * - MCP_DASHBOARD_SPEC_v1.0.md의 API를 로컬 개발 환경에서 재현
+ * - Background Sync가 전송하는 EncryptedPacket을 수신/복호화/저장
+ *
+ * Endpoints:
+ * - GET  /healthz         - K8s liveness probe (200=alive)
+ * - GET  /readyz          - K8s readiness probe (200=ready, 503=not ready)
+ * - GET  /api/v1/health   - Health check (legacy)
+ * - POST /api/v1/sync     - Receive encrypted sync packet
+ * - GET  /api/v1/runs     - List all runs
+ * - GET  /api/v1/runs/:id - Get specific run
+ *
+ * NOTE:
+ * - 프로덕션 서버는 별도 분리 가능 (여긴 최소 로컬 서버)
+ */
+import * as http from "node:http";
+export interface DashboardServerOptions {
+    host?: string;
+    port?: number;
+    /** 저장 디렉토리 (기본: ~/.vibe/dashboard) */
+    storageDir?: string;
+    /**
+     * Bearer 토큰 검증 (선택)
+     * - 설정 시: Authorization: Bearer <token>이 일치해야 함
+     */
+    authToken?: string | null;
+    /**
+     * 복호화에 쓰는 secret (기본: authToken)
+     * - 미설정이면 요청의 Bearer 토큰(있는 경우)을 secret으로 사용
+     */
+    secretKey?: string | null;
+    /** request body 제한 (bytes) */
+    maxBodyBytes?: number;
+}
+export interface DashboardServerHandle {
+    server: http.Server;
+    url: string;
+    close: () => Promise<void>;
+}
+export declare function startDashboardServer(opts?: DashboardServerOptions): DashboardServerHandle;

package/build/dashboard/server.js

@@ -0,0 +1,334 @@
+/**
+ * Local Dashboard Server (MVP)
+ *
+ * 목표:
+ * - MCP_DASHBOARD_SPEC_v1.0.md의 API를 로컬 개발 환경에서 재현
+ * - Background Sync가 전송하는 EncryptedPacket을 수신/복호화/저장
+ *
+ * Endpoints:
+ * - GET  /healthz         - K8s liveness probe (200=alive)
+ * - GET  /readyz          - K8s readiness probe (200=ready, 503=not ready)
+ * - GET  /api/v1/health   - Health check (legacy)
+ * - POST /api/v1/sync     - Receive encrypted sync packet
+ * - GET  /api/v1/runs     - List all runs
+ * - GET  /api/v1/runs/:id - Get specific run
+ *
+ * NOTE:
+ * - 프로덕션 서버는 별도 분리 가능 (여긴 최소 로컬 서버)
+ */
+import * as http from "node:http";
+import { createLivenessHandler, createReadinessHandler, serverRunningChecker, } from "../health/index.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+import { SyncPacketBuilder } from "../sync-packet-builder.js";
+const DEFAULT_STORAGE_DIR = path.join(os.homedir(), ".vibe", "dashboard");
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+function sendJson(res, status, obj) {
+    const body = JSON.stringify(obj, null, 2);
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.end(body);
+}
+function sendText(res, status, text) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.end(text);
+}
+function readRequestBody(req, maxBytes) {
+    return new Promise((resolve, reject) => {
+        let total = 0;
+        let chunks = [];
+        let rejected = false;
+        req.on("data", (chunk) => {
+            if (rejected)
+                return;
+            total += chunk.length;
+            if (total > maxBytes) {
+                rejected = true;
+                chunks = []; // Release memory immediately
+                reject(new Error("body_too_large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            if (rejected)
+                return;
+            const result = Buffer.concat(chunks).toString("utf-8");
+            chunks = []; // Release memory after concatenation
+            resolve(result);
+        });
+        req.on("error", (err) => {
+            chunks = []; // Release memory on error
+            reject(err);
+        });
+    });
+}
+function parseBearerToken(req) {
+    const raw = String(req.headers["authorization"] ?? "");
+    const m = raw.match(/^Bearer\s+(.+)$/i);
+    return m?.[1]?.trim() || null;
+}
+function verifySignatureIfConfigured(packet) {
+    const publicKeyPem = (process.env.VIBE_CLOUD_SYNC_SIGNING_PUBLIC_KEY_PEM || "").trim();
+    if (!publicKeyPem)
+        return { ok: true };
+    if (!packet.signature)
+        return { ok: false, message: "missing_signature" };
+    try {
+        const payload = Buffer.from(`${packet.run_id}.${packet.iv}.${packet.tag}.${packet.content}.${packet.version}`, "utf-8");
+        const sig = Buffer.from(packet.signature, "base64url");
+        const ok = crypto.verify(null, payload, crypto.createPublicKey(publicKeyPem), sig);
+        if (!ok)
+            return { ok: false, message: "invalid_signature" };
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, message: err instanceof Error ? err.message : String(err) };
+    }
+}
+function listRunFiles(storageDir) {
+    const dir = path.join(storageDir, "runs");
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+}
+function loadRunPacket(storageDir, runId) {
+    const file = path.join(storageDir, "runs", `${runId}.json`);
+    try {
+        const raw = fs.readFileSync(file, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function saveRunPacket(storageDir, packet) {
+    ensureDir(path.join(storageDir, "runs"));
+    const file = path.join(storageDir, "runs", `${packet.metadata.run_id}.json`);
+    fs.writeFileSync(file, JSON.stringify(packet, null, 2), "utf-8");
+}
+export function startDashboardServer(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const port = opts.port ?? Number(process.env.VIBE_DASHBOARD_PORT || 8787);
+    const storageDir = opts.storageDir ?? process.env.VIBE_DASHBOARD_DIR ?? DEFAULT_STORAGE_DIR;
+    const authToken = opts.authToken ?? (process.env.VIBE_CLOUD_SYNC_TOKEN || null);
+    const secretKey = opts.secretKey ?? authToken;
+    const maxBodyBytes = opts.maxBodyBytes ?? 1_000_000;
+    ensureDir(storageDir);
+    ensureDir(path.join(storageDir, "runs"));
+    const builder = new SyncPacketBuilder();
+    // K8s health probe handlers
+    const handleLiveness = createLivenessHandler({
+        version: process.env.npm_package_version,
+        component: "dashboard",
+    });
+    const handleReadiness = createReadinessHandler([
+        serverRunningChecker(),
+    ]);
+    const server = http.createServer(async (req, res) => {
+        // CORS preflight (minimal)
+        if (req.method === "OPTIONS") {
+            res.statusCode = 204;
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+            res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+            res.end();
+            return;
+        }
+        const url = new URL(req.url ?? "/", `http://${req.headers.host || "localhost"}`);
+        // K8s liveness probe
+        if (req.method === "GET" && url.pathname === "/healthz") {
+            handleLiveness(req, res);
+            return;
+        }
+        // K8s readiness probe
+        if (req.method === "GET" && url.pathname === "/readyz") {
+            await handleReadiness(req, res);
+            return;
+        }
+        // Legacy health check
+        if (req.method === "GET" && url.pathname === "/api/v1/health") {
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        if (req.method === "POST" && url.pathname === "/api/v1/sync") {
+            try {
+                const bearer = parseBearerToken(req);
+                if (authToken && bearer !== authToken) {
+                    sendJson(res, 401, { ok: false, error: "unauthorized" });
+                    return;
+                }
+                const body = await readRequestBody(req, maxBodyBytes);
+                const raw = JSON.parse(body);
+                const encrypted = raw;
+                if (!encrypted || typeof encrypted !== "object") {
+                    sendJson(res, 400, { ok: false, error: "invalid_json" });
+                    return;
+                }
+                if (!encrypted.run_id || !encrypted.iv || !encrypted.tag || !encrypted.content || !encrypted.version) {
+                    sendJson(res, 400, { ok: false, error: "invalid_encrypted_packet" });
+                    return;
+                }
+                const sigCheck = verifySignatureIfConfigured(encrypted);
+                if (!sigCheck.ok) {
+                    sendJson(res, 400, { ok: false, error: "signature_invalid", message: sigCheck.message });
+                    return;
+                }
+                const key = (secretKey || bearer || "").trim();
+                if (!key) {
+                    sendJson(res, 400, { ok: false, error: "missing_secret_key" });
+                    return;
+                }
+                const packet = builder.decrypt(encrypted, key);
+                saveRunPacket(storageDir, packet);
+                sendJson(res, 200, { ok: true, run_id: packet.metadata.run_id, received_at: new Date().toISOString() });
+                return;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                sendJson(res, 500, { ok: false, error: "sync_failed", message: msg });
+                return;
+            }
+        }
+        if (req.method === "GET" && url.pathname === "/api/v1/runs") {
+            const runs = listRunFiles(storageDir)
+                .map((f) => f.replace(/\.json$/, ""))
+                .sort();
+            sendJson(res, 200, { runs });
+            return;
+        }
+        if (req.method === "GET" && url.pathname.startsWith("/api/v1/runs/")) {
+            const runId = decodeURIComponent(url.pathname.split("/").slice(-1)[0] || "");
+            const pkt = loadRunPacket(storageDir, runId);
+            if (!pkt) {
+                sendJson(res, 404, { ok: false, error: "not_found" });
+                return;
+            }
+            sendJson(res, 200, pkt);
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/v1/stats/roi") {
+            const files = listRunFiles(storageDir);
+            let tokensSaved = 0;
+            let inputTokens = 0;
+            let outputTokens = 0;
+            for (const f of files) {
+                const runId = f.replace(/\.json$/, "");
+                const pkt = loadRunPacket(storageDir, runId);
+                if (!pkt)
+                    continue;
+                const saved = pkt.metrics?.token_usage?.saved_by_skeleton ?? 0;
+                const input = pkt.metrics?.token_usage?.input ?? 0;
+                const output = pkt.metrics?.token_usage?.output ?? 0;
+                tokensSaved += saved;
+                inputTokens += input;
+                outputTokens += output;
+            }
+            const dollarSaved = (tokensSaved / 1000) * 0.015;
+            sendJson(res, 200, {
+                period: "all",
+                total_runs: files.length,
+                metrics: {
+                    tokens_saved: tokensSaved,
+                    dollar_saved: Number(dollarSaved.toFixed(2)),
+                    hours_saved: 0,
+                    auto_fixes: 0,
+                    auto_fix_success_rate: 0,
+                    token_usage: {
+                        input: inputTokens,
+                        output: outputTokens,
+                    },
+                },
+                comparison: {
+                    vs_last_month: "n/a",
+                    vs_last_quarter: "n/a",
+                },
+            });
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/v1/stats/safety") {
+            const files = listRunFiles(storageDir);
+            const counts = { GO: 0, FIX: 0, BLOCK: 0 };
+            for (const f of files) {
+                const runId = f.replace(/\.json$/, "");
+                const pkt = loadRunPacket(storageDir, runId);
+                const v = pkt?.verdict_summary?.final_verdict;
+                if (v === "GO" || v === "FIX" || v === "BLOCK")
+                    counts[v]++;
+            }
+            const total = files.length || 0;
+            const passRate = total > 0 ? counts.GO / total : 0;
+            sendJson(res, 200, {
+                period: "all",
+                total_runs: total,
+                verdicts: counts,
+                pass_rate: Number((passRate * 100).toFixed(2)),
+                trend: "unknown",
+            });
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/v1/stats/violations") {
+            const files = listRunFiles(storageDir);
+            const counts = {};
+            for (const f of files) {
+                const runId = f.replace(/\.json$/, "");
+                const pkt = loadRunPacket(storageDir, runId);
+                if (!pkt)
+                    continue;
+                for (const v of pkt.violation_details ?? []) {
+                    const key = String(v.type || "UNKNOWN");
+                    counts[key] = (counts[key] ?? 0) + 1;
+                }
+            }
+            const totalViolations = Object.values(counts).reduce((a, b) => a + b, 0);
+            const byType = Object.entries(counts)
+                .sort((a, b) => b[1] - a[1])
+                .map(([type, count]) => ({
+                type,
+                count,
+                percentage: totalViolations > 0 ? Math.round((count / totalViolations) * 100) : 0,
+            }));
+            sendJson(res, 200, {
+                period: "all",
+                total_violations: totalViolations,
+                by_type: byType,
+                trend: "unknown",
+            });
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/v1/license") {
+            const bearer = parseBearerToken(req);
+            const ok = authToken ? bearer === authToken : true;
+            sendJson(res, 200, {
+                ok,
+                auth_required: Boolean(authToken),
+                plan: authToken ? "PRO" : "ALL",
+            });
+            return;
+        }
+        sendText(res, 404, "Not Found");
+    });
+    server.listen(port, host);
+    const url = `http://${host}:${port}`;
+    return {
+        server,
+        url,
+        close: () => new Promise((resolve, reject) => {
+            server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        }),
+    };
+}

package/build/db_sync/config.d.ts

@@ -0,0 +1,76 @@
+/**
+ * db_sync/config.ts
+ *
+ * PostgreSQL Secondary Truth Layer - Configuration
+ *
+ * @description
+ * 환경변수에서 DB 동기화 설정을 읽어옵니다.
+ * Rail은 바이너리/엔트리포인트에서 고정되어야 합니다 (env로 런타임 변경 금지).
+ *
+ * @see docs/DEV_SPEC/active/postgresql-secondary-truth/CONTRACT.md
+ */
+import { type DbConfig, type PoolConfig, type Rail } from "./types.js";
+/**
+ * DB 동기화 활성화 여부
+ *
+ * @returns VIBE_DB_SYNC_ENABLED=1이고 VIBE_DB_URL이 설정된 경우 true
+ */
+export declare function isDbSyncEnabled(): boolean;
+/**
+ * DB 동기화 설정 조회
+ *
+ * @param defaultRail 기본 레일 (엔트리포인트에서 고정)
+ * @returns DbConfig 객체
+ *
+ * @example
+ * // vibe-ci.ts에서
+ * const config = getDbConfig('local');
+ *
+ * // MCP router에서
+ * const config = getDbConfig('mcp');
+ */
+export declare function getDbConfig(defaultRail: Rail): DbConfig;
+/**
+ * 커넥션 풀 설정 조회
+ *
+ * @returns PoolConfig 객체
+ */
+export declare function getPoolConfig(): PoolConfig;
+/**
+ * PostgreSQL 접속 URL 조회
+ *
+ * @returns DB URL 또는 undefined
+ */
+export declare function getDbUrl(): string | undefined;
+/**
+ * 명시적 workspace_id 조회
+ *
+ * @returns workspace_id 또는 undefined (자동 생성 필요)
+ */
+export declare function getExplicitWorkspaceId(): string | undefined;
+/**
+ * DB 설정 유효성 검사
+ *
+ * @param config DbConfig
+ * @throws Error if configuration is invalid
+ */
+export declare function validateDbConfig(config: DbConfig): void;
+/**
+ * Rail 일치 여부 검사 (엔트리포인트 고정 원칙)
+ *
+ * @param expected 기대하는 rail (바이너리에서 고정)
+ * @param actual 실제 rail (환경변수 또는 인자)
+ * @throws Error if rails don't match
+ *
+ * @description
+ * P0-1: Rail은 바이너리/엔트리포인트에서 고정되어야 합니다.
+ * vibe-ci.ts는 항상 'local', MCP router는 항상 'mcp'.
+ */
+export declare function assertRailMatch(expected: Rail, actual: Rail): void;
+/**
+ * 현재 DB 동기화 설정을 로그 형식으로 반환
+ *
+ * @param rail 레일
+ * @returns 디버그 문자열
+ */
+export declare function getDbConfigSummary(rail: Rail): string;