@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/hive-bridge/tools/nodes.js

@@ -0,0 +1,30 @@
+/**
+ * hive.nodes — List connected HiveLink nodes
+ */
+import { isPrimeConfigured } from "../../musu-bridge/client.js";
+import { primeGet } from "../../musu-bridge/client.js";
+import { renderForHuman } from "../../ai-native/envelope.js";
+import { infoResponse } from "../../ai-native/envelope.js";
+export const hiveNodesTool = {
+    name: "hive.nodes",
+    description: "List connected HiveLink nodes and their capabilities",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    handler: async () => {
+        if (!isPrimeConfigured()) {
+            const envelope = infoResponse({ nodes: [], available: false }, "MUSU_PRIME_URL not configured — cannot query gateway.");
+            return {
+                content: [{ type: "text", text: renderForHuman(envelope) }],
+                _ai_native: envelope,
+            };
+        }
+        const envelope = await primeGet("/v1/gateway/status");
+        return {
+            content: [{ type: "text", text: renderForHuman(envelope) }],
+            _ai_native: envelope,
+        };
+    },
+};

package/build/mcp/hive-bridge/tools/run_command.d.ts

@@ -0,0 +1,36 @@
+/**
+ * hive.run_command — Execute a shell command on a HiveLink node
+ */
+export declare const hiveRunCommandTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            command: {
+                type: string;
+                description: string;
+            };
+            working_dir: {
+                type: string;
+                description: string;
+            };
+            timeout_secs: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (input: {
+        command: string;
+        working_dir?: string;
+        timeout_secs?: number;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../../ai-native/envelope.js").AiNativeResponse<unknown>;
+    }>;
+};

package/build/mcp/hive-bridge/tools/run_command.js

@@ -0,0 +1,39 @@
+/**
+ * hive.run_command — Execute a shell command on a HiveLink node
+ */
+import { hiveDispatch, wrapHiveResult } from "../client.js";
+import { renderForHuman } from "../../ai-native/envelope.js";
+export const hiveRunCommandTool = {
+    name: "hive.run_command",
+    description: "Execute a shell command on a remote HiveLink node",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "Shell command to execute",
+            },
+            working_dir: {
+                type: "string",
+                description: "Working directory (optional)",
+            },
+            timeout_secs: {
+                type: "number",
+                description: "Timeout in seconds (default: 30)",
+            },
+        },
+        required: ["command"],
+    },
+    handler: async (input) => {
+        const envelope = await hiveDispatch("remote_compute", {
+            command: input.command,
+            working_dir: input.working_dir,
+            timeout_secs: input.timeout_secs ?? 30,
+        });
+        const result = wrapHiveResult(envelope, "Remote command");
+        return {
+            content: [{ type: "text", text: renderForHuman(result) }],
+            _ai_native: result,
+        };
+    },
+};

package/build/mcp/hive-bridge/tools/submit_job.d.ts

@@ -0,0 +1,36 @@
+/**
+ * hive.submit_job — Submit an async job to a HiveLink node
+ */
+export declare const hiveSubmitJobTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            command: {
+                type: string;
+                description: string;
+            };
+            working_dir: {
+                type: string;
+                description: string;
+            };
+            timeout_secs: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (input: {
+        command: string;
+        working_dir?: string;
+        timeout_secs?: number;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        _ai_native: import("../../ai-native/envelope.js").AiNativeResponse<unknown>;
+    }>;
+};

package/build/mcp/hive-bridge/tools/submit_job.js

@@ -0,0 +1,40 @@
+/**
+ * hive.submit_job — Submit an async job to a HiveLink node
+ */
+import { hiveDispatch, wrapHiveResult } from "../client.js";
+import { renderForHuman } from "../../ai-native/envelope.js";
+export const hiveSubmitJobTool = {
+    name: "hive.submit_job",
+    description: "Submit an async compute job to a HiveLink node (returns job ID)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "Command to execute",
+            },
+            working_dir: {
+                type: "string",
+                description: "Working directory",
+            },
+            timeout_secs: {
+                type: "number",
+                description: "Max execution time in seconds",
+            },
+        },
+        required: ["command"],
+    },
+    handler: async (input) => {
+        const envelope = await hiveDispatch("remote_compute", {
+            command: input.command,
+            working_dir: input.working_dir,
+            timeout_secs: input.timeout_secs,
+            async: true,
+        });
+        const result = wrapHiveResult(envelope, "Job submitted");
+        return {
+            content: [{ type: "text", text: renderForHuman(result) }],
+            _ai_native: result,
+        };
+    },
+};

package/build/mcp/index.js

@@ -1,18 +1,26 @@
 #!/usr/bin/env node
 // MVP Core Clinic - MCP Server
 // Tool count varies by VIBE_PROFILE (default: all)
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { fileURLToPath } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { registerAllTools } from "./tool-registry.js";
-import { parseTransportArgs, startHttpTransport } from "./transport/index.js";
-import { startEventLoop } from "./events/index.js";
-import { initPooledMapperClient } from "../mapper-worker/index.js";
-import { startAllComponents, registerShutdownHandlers, logStartupSummary, getDisabledComponents, } from "../startup/index.js";
-import { checkVersion, sendUsagePing, getClientId, needsUpdate, hasNewerVersion, } from "../coordinator/index.js";
+import * as os from 'node:os';
+import { getPackageVersion } from '../kernel/paths.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerAllTools } from './tool-registry.js';
+import { parseTransportArgs, startHttpTransport } from './transport/index.js';
+import { startEventLoop } from './events/index.js';
+import { initPooledMapperClient } from '../mapper-worker/index.js';
+import { registerVibeResources } from './resources/vibe.js';
+import { registerVibePrompts } from './prompts/vibe.js';
+import { registerAgentPersonaPrompts } from './prompts/agent_personas.js';
+import { startAllComponents, registerShutdownHandlers, logStartupSummary, getDisabledComponents, } from '../startup/index.js';
+import { loadEntitlements } from '../license-manager.js';
+import { checkVersion, sendUsagePing, getClientId, needsUpdate, hasNewerVersion, } from '../coordinator/index.js';
+import { createKernelDeps } from '../kernel/deps.js';
+import { validateCache } from './bootstrap/installer.js';
+import { logger } from '../shared/logger.js';
+import { installProcessGuard } from '../shared/process-guard.js';
+// Install global error handlers before any async work
+installProcessGuard();
 /**
  * Vibe PM MCP Server
  *
@@ -37,19 +45,8 @@ import { checkVersion, sendUsagePing, getClientId, needsUpdate, hasNewerVersion,
  *
  * See profile-config.ts for full profile definitions.
  */
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SERVER_VERSION = (() => {
-    try {
-        const pkgPath = path.join(__dirname, "..", "package.json");
-        const raw = fs.readFileSync(pkgPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        return parsed.version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-})();
-console.error(`[vibe-pm] MVP Core v${SERVER_VERSION}`);
+const SERVER_VERSION = getPackageVersion();
+logger.info({ version: SERVER_VERSION }, 'MVP Core starting');
 // ============================================================
 // Version check and usage tracking (non-blocking)
 // ============================================================
@@ -58,11 +55,10 @@ async function checkVersionAsync() {
     cachedVersionInfo = await checkVersion();
     if (cachedVersionInfo) {
         if (needsUpdate(SERVER_VERSION, cachedVersionInfo.minimum)) {
-            console.error(`[vibe-pm] ⚠️ Update required: v${SERVER_VERSION} → v${cachedVersionInfo.latest}`);
-            console.error(`[vibe-pm] Minimum supported: v${cachedVersionInfo.minimum}`);
+            logger.warn({ current: SERVER_VERSION, latest: cachedVersionInfo.latest, minimum: cachedVersionInfo.minimum }, 'Update required');
         }
         else if (hasNewerVersion(SERVER_VERSION, cachedVersionInfo.latest)) {
-            console.error(`[vibe-pm] New version available: v${cachedVersionInfo.latest}`);
+            logger.info({ latest: cachedVersionInfo.latest }, 'New version available');
         }
     }
 }
@@ -78,18 +74,37 @@ async function sendStartupPing() {
     await sendUsagePing({
         client_id: getClientId(),
         version: SERVER_VERSION,
-        events: [{ type: "mcp_start", count: 1 }],
-        plan: "FREE", // TODO: get from license manager
+        events: [{ type: 'mcp_start', count: 1 }],
+        plan: loadEntitlements().planEffective,
         os: os.platform(),
         arch: os.arch(),
     });
 }
 const server = new McpServer({
-    name: "vibe-pm",
-    version: SERVER_VERSION
+    name: 'vibe-pm',
+    version: SERVER_VERSION,
 });
+// Enable MCP logging notifications (notifications/message).
+server.server.registerCapabilities({ logging: {} });
+// Kernel deps (SSOT instances) for this workspace.
+const kernelDeps = createKernelDeps(process.cwd());
 // MVP 도구 정의 (lazy import 기반)
-await registerAllTools(server);
+await registerAllTools(server, { kernelDeps });
+// MCP Resources/Prompts (P2)
+registerVibeResources(server, kernelDeps.paths.workspaceRoot);
+registerVibePrompts(server);
+registerAgentPersonaPrompts(server);
+// P3: validate engine cache (no downloads). JIT acquisition handles installs.
+try {
+    const cache = await validateCache();
+    const invalid = Object.entries(cache).filter(([, v]) => !v.valid).map(([k]) => k);
+    if (invalid.length > 0) {
+        logger.warn({ engines: invalid }, 'Engine cache missing/corrupted — will install on demand');
+    }
+}
+catch {
+    // best-effort
+}
 // ============================================================
 // Start all optional components (unified startup)
 //
@@ -104,20 +119,68 @@ await registerAllTools(server);
 // ============================================================
 // Start event loop (file watcher based). MQ is optional; SSOT is file.
 let eventLoop = null;
+let signalBridge = null;
 const startupResult = await startAllComponents();
+// P36: DB 미연결 시 Fast Fail (모든 모드)
+const dbStatus = startupResult.components.find(c => c.name === 'DbSync');
+if (dbStatus && !dbStatus.running) {
+    logger.fatal({ error: dbStatus.error }, 'PostgreSQL connection failed — set VIBE_DB_URL');
+    process.exit(1);
+}
+// Connect Block events to Rust signal bus bridge (default on).
+try {
+    const bridgeEnabled = !['0', 'false', 'off'].includes((process.env.VIBE_SIGNAL_BRIDGE ?? '1').trim().toLowerCase());
+    if (bridgeEnabled) {
+        const emitter = kernelDeps.eventEmitter;
+        const bridge = kernelDeps.signalBridge;
+        signalBridge = bridge;
+        bridge.connect(emitter);
+    }
+}
+catch (e) {
+    logger.error({ err: e }, 'Signal bridge connect failed');
+}
+// P37: Block → DB sync (event-driven, fire-and-forget)
+let blockSyncHandle = null;
+try {
+    const dbOk = startupResult.components.find(c => c.name === 'DbSync')?.running;
+    if (dbOk) {
+        const { connectBlockSync } = await import('../db_sync/block_sync.js');
+        const { getPool } = await import('../db_sync/pool.js');
+        const dbPool = await getPool('mcp');
+        const emitter = kernelDeps.eventEmitter;
+        const store = kernelDeps.blockStore;
+        blockSyncHandle = connectBlockSync(emitter, dbPool, store);
+        logger.info('Block→DB sync connected');
+        // P38: Initial FS → DB migration (one-time, idempotent)
+        try {
+            const { migrateBlocksToDb } = await import('../db_sync/block_migration.js');
+            const migResult = await migrateBlocksToDb(dbPool, store);
+            if (migResult.blocksMigrated > 0 || migResult.chainsMigrated > 0) {
+                logger.info({ blocks: migResult.blocksMigrated, chains: migResult.chainsMigrated, durationMs: migResult.durationMs }, 'Block migration completed');
+            }
+        }
+        catch (migErr) {
+            logger.error({ err: migErr }, 'Block migration failed');
+        }
+    }
+}
+catch (e) {
+    logger.error({ err: e }, 'Block sync connect failed');
+}
 // Initialize event loop after components (uses workspace root = cwd)
 try {
     eventLoop = startEventLoop(process.cwd());
 }
 catch (e) {
-    console.error(`[vibe-pm] Event loop start failed: ${e instanceof Error ? e.message : String(e)}`);
+    logger.error({ err: e }, 'Event loop start failed');
 }
 // Initialize pooled mapper client if mapper pool started
-const mapperPoolStatus = startupResult.components.find(c => c.name === "MapperPool");
+const mapperPoolStatus = startupResult.components.find(c => c.name === 'MapperPool');
 if (mapperPoolStatus?.running) {
     try {
         // Dynamically import to get the pool handle
-        const { getMapperPool } = await import("../mapper-worker/index.js");
+        const { getMapperPool } = await import('../mapper-worker/index.js');
         const pool = getMapperPool();
         if (pool) {
             initPooledMapperClient(pool);
@@ -132,7 +195,7 @@ logStartupSummary(startupResult);
 // Log disabled components hint
 const disabled = getDisabledComponents();
 if (disabled.length > 0) {
-    console.error(`[vibe-pm] Disabled: ${disabled.join(", ")}`);
+    logger.info({ components: disabled }, 'Disabled components');
 }
 // Register graceful shutdown handlers
 registerShutdownHandlers();
@@ -140,29 +203,28 @@ registerShutdownHandlers();
 // Start transport (HTTP or stdio)
 // ============================================================
 const transportOpts = parseTransportArgs();
-if (transportOpts.transport === "http") {
+if (transportOpts.transport === 'http') {
     // HTTP mode for K8s deployment
     const httpHandle = await startHttpTransport(server, {
         port: transportOpts.port,
         host: transportOpts.host,
         version: SERVER_VERSION,
     });
-    console.error(`[vibe-pm] MCP Server ready (HTTP mode)`);
-    console.error(`[vibe-pm] Endpoints:`);
-    console.error(`  GET  ${httpHandle.url}/healthz     - Liveness probe`);
-    console.error(`  GET  ${httpHandle.url}/readyz      - Readiness probe`);
-    console.error(`  GET  ${httpHandle.url}/mcp/tools   - List tools`);
-    console.error(`  POST ${httpHandle.url}/mcp/call    - Call tool`);
+    logger.info({ url: httpHandle.url, transport: 'http' }, 'MCP Server ready');
     // Handle shutdown
-    process.on("SIGTERM", async () => {
-        console.error("[vibe-pm] SIGTERM received, shutting down...");
+    process.on('SIGTERM', async () => {
+        logger.info('SIGTERM received, shutting down...');
         await eventLoop?.stop();
+        blockSyncHandle?.disconnect();
+        signalBridge?.disconnect();
         await httpHandle.close();
         process.exit(0);
     });
-    process.on("SIGINT", async () => {
-        console.error("[vibe-pm] SIGINT received, shutting down...");
+    process.on('SIGINT', async () => {
+        logger.info('SIGINT received, shutting down...');
         await eventLoop?.stop();
+        blockSyncHandle?.disconnect();
+        signalBridge?.disconnect();
         await httpHandle.close();
         process.exit(0);
     });
@@ -171,17 +233,18 @@ else {
     // stdio mode (default) for Claude Desktop
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`[vibe-pm] MCP Server ready (stdio mode)`);
+    logger.info({ transport: 'stdio' }, 'MCP Server ready');
 }
 // Graceful shutdown for stdio mode
-process.on("SIGINT", async () => {
+process.on('SIGINT', async () => {
     await eventLoop?.stop();
+    blockSyncHandle?.disconnect();
+    signalBridge?.disconnect();
 });
-process.on("SIGTERM", async () => {
+process.on('SIGTERM', async () => {
     await eventLoop?.stop();
+    blockSyncHandle?.disconnect();
+    signalBridge?.disconnect();
 });
 // Non-blocking version check and usage ping
-Promise.all([
-    checkVersionAsync().catch(() => { }),
-    sendStartupPing().catch(() => { }),
-]).catch(() => { });
+Promise.all([checkVersionAsync().catch(() => { }), sendStartupPing().catch(() => { })]).catch(() => { });

package/build/mcp/mcp-logger.d.ts

@@ -0,0 +1,13 @@
+export type McpExtra = {
+    sendNotification?: (notification: {
+        method: string;
+        params?: Record<string, unknown>;
+        _meta?: Record<string, unknown>;
+    }) => Promise<unknown> | unknown;
+};
+export type McpLogLevel = 'debug' | 'info' | 'notice' | 'warning' | 'error' | 'critical';
+export type McpLogTag = 'vibe-pm/gate' | 'vibe-pm/engine' | 'vibe-pm/block' | 'vibe-pm/agent' | 'vibe-pm/concurrency';
+export interface McpLogger {
+    log(level: McpLogLevel, data: Record<string, unknown>, message?: string): void;
+}
+export declare function createMcpLogger(extra: unknown, tag: McpLogTag): McpLogger;

package/build/mcp/mcp-logger.js

@@ -0,0 +1,18 @@
+export function createMcpLogger(extra, tag) {
+    const sendNotification = extra?.sendNotification;
+    if (typeof sendNotification !== 'function') {
+        return { log() { } };
+    }
+    return {
+        log(level, data, message) {
+            void Promise.resolve(sendNotification({
+                method: 'notifications/message',
+                params: {
+                    level,
+                    logger: tag,
+                    data: message ? { message, ...data } : data,
+                },
+            })).catch(() => { });
+        },
+    };
+}

package/build/mcp/metrics/collector.d.ts

@@ -21,3 +21,30 @@ export declare class MetricCollector implements MetricRegistry {
 }
 export declare function getGlobalRegistry(): MetricCollector;
 export declare function resetGlobalRegistry(): void;
+/**
+ * When VIBE_OTEL=1, this registers the three core metrics
+ * (`vibe_tool_calls_total`, `vibe_tool_duration_seconds`,
+ * `vibe_engine_health`) with the OTel meter so they appear in
+ * the Prometheus scrape.
+ *
+ * The bridge is additive: the existing MetricCollector keeps
+ * working as before; OTel simply gets a parallel feed.
+ */
+export interface OtelMetricsBridge {
+    toolCallsCounter: {
+        add: (v: number, attrs?: Record<string, string>) => void;
+    };
+    toolDurationHistogram: {
+        record: (v: number, attrs?: Record<string, string>) => void;
+    };
+    engineHealthGauge: {
+        add: (v: number, attrs?: Record<string, string>) => void;
+    };
+}
+export declare function getOtelBridge(): OtelMetricsBridge | null;
+/**
+ * Connect an OTel meter to the collector.
+ * Called once during initOtel setup.
+ */
+export declare function connectOtelMeter(bridge: OtelMetricsBridge): void;
+export declare function disconnectOtelMeter(): void;

package/build/mcp/metrics/collector.js

@@ -54,9 +54,11 @@ export class MetricCollector {
                 this.metrics.set(definition.name, { type: "histogram", definition: definition, buckets: new Map(), sums: new Map(), counts: new Map(), labels: new Map() });
                 break;
             case "summary":
-                const summaryDef = definition;
-                this.metrics.set(definition.name, { type: "summary", definition: summaryDef, observations: new Map(), sums: new Map(), counts: new Map(), labels: new Map(), maxAgeMs: summaryDef.maxAgeMs ?? 600000, timestamps: new Map() });
-                break;
+                {
+                    const summaryDef = definition;
+                    this.metrics.set(definition.name, { type: "summary", definition: summaryDef, observations: new Map(), sums: new Map(), counts: new Map(), labels: new Map(), maxAgeMs: summaryDef.maxAgeMs ?? 600000, timestamps: new Map() });
+                    break;
+                }
         }
     }
     incCounter(name, labels = {}, value = 1) {
@@ -268,3 +270,17 @@ export function resetGlobalRegistry() {
         globalRegistry.reset();
     globalRegistry = null;
 }
+let otelBridge = null;
+export function getOtelBridge() {
+    return otelBridge;
+}
+/**
+ * Connect an OTel meter to the collector.
+ * Called once during initOtel setup.
+ */
+export function connectOtelMeter(bridge) {
+    otelBridge = bridge;
+}
+export function disconnectOtelMeter() {
+    otelBridge = null;
+}

package/build/mcp/metrics/index.d.ts

@@ -3,6 +3,7 @@
  */
 export type { MetricType, MetricLabels, MetricDefinition, CounterDefinition, GaugeDefinition, HistogramDefinition, SummaryDefinition, CounterValue, GaugeValue, HistogramValue, SummaryValue, AnySample, CounterSample, GaugeSample, HistogramSample, SummarySample, MetricRegistry, } from "./types.js";
 export { DEFAULT_LATENCY_BUCKETS, DEFAULT_QUEUE_BUCKETS, VIBE_PM_METRICS, METRICS_ENV_VARS, isMetricsEnabled, getMetricsPort, getMetricsPath, shouldIncludeProcessMetrics, } from "./types.js";
-export { MetricCollector, getGlobalRegistry, resetGlobalRegistry } from "./collector.js";
+export { MetricCollector, getGlobalRegistry, resetGlobalRegistry, connectOtelMeter, disconnectOtelMeter, getOtelBridge } from "./collector.js";
+export type { OtelMetricsBridge } from "./collector.js";
 export type { MetricsServerOptions } from "./server.js";
 export { registerDefaultMetrics, startMetricsServer, stopMetricsServer, isMetricsServerRunning, getMetricsServerInfo, maybeStartMetricsServer, incCounter, setGauge, observeHistogram, observeSummary, recordToolInvocation, recordPoolRequest, updatePoolMetrics, updateResourceMetrics, recordRecoveryAttempt, recordRecoveryAction, updateMemoryMetrics, recordMemorySync, recordMemoryQuery, updateBitNetWorkerMetrics, } from "./server.js";

package/build/mcp/metrics/index.js

@@ -2,5 +2,5 @@
  * Prometheus Metrics Module
  */
 export { DEFAULT_LATENCY_BUCKETS, DEFAULT_QUEUE_BUCKETS, VIBE_PM_METRICS, METRICS_ENV_VARS, isMetricsEnabled, getMetricsPort, getMetricsPath, shouldIncludeProcessMetrics, } from "./types.js";
-export { MetricCollector, getGlobalRegistry, resetGlobalRegistry } from "./collector.js";
+export { MetricCollector, getGlobalRegistry, resetGlobalRegistry, connectOtelMeter, disconnectOtelMeter, getOtelBridge } from "./collector.js";
 export { registerDefaultMetrics, startMetricsServer, stopMetricsServer, isMetricsServerRunning, getMetricsServerInfo, maybeStartMetricsServer, incCounter, setGauge, observeHistogram, observeSummary, recordToolInvocation, recordPoolRequest, updatePoolMetrics, updateResourceMetrics, recordRecoveryAttempt, recordRecoveryAction, updateMemoryMetrics, recordMemorySync, recordMemoryQuery, updateBitNetWorkerMetrics, } from "./server.js";

package/build/mcp/metrics/server.js

@@ -54,7 +54,14 @@ export async function stopMetricsServer() {
     if (!metricsServer || !isStarted)
         return;
     return new Promise((resolve, reject) => {
-        metricsServer.close((err) => { isStarted = false; metricsServer = null; err ? reject(err) : resolve(); });
+        metricsServer.close((err) => {
+            isStarted = false;
+            metricsServer = null;
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
     });
 }
 export function isMetricsServerRunning() { return isStarted && metricsServer !== null; }

package/build/mcp/musu-bridge/client.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Musu Prime HTTP Client
+ * Bridges MCP tools to the Musu Prime REST API (:8791).
+ */
+import type { AiNativeResponse } from "../ai-native/envelope.js";
+/** True when MUSU_PRIME_URL is configured. */
+export declare function isPrimeConfigured(): boolean;
+/** Check if Musu Prime is reachable. */
+export declare function isPrimeAvailable(): Promise<boolean>;
+/** GET request to Prime, returns the AI-Native envelope. */
+export declare function primeGet<T = unknown>(path: string): Promise<AiNativeResponse<T>>;
+/** POST request to Prime, returns the AI-Native envelope. */
+export declare function primePost<T = unknown>(path: string, body: unknown): Promise<AiNativeResponse<T>>;