@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/ai-native/health.js

@@ -0,0 +1,97 @@
+/**
+ * system.health — Unified health check across all 3 products
+ *
+ * signal: GO (all up) / FIX (some down) / BLOCK (all down)
+ */
+import { isPrimeConfigured, isPrimeAvailable, primeGet } from "../musu-bridge/client.js";
+import { wrapResponse, nextToolCall, nextDone, renderForHuman, } from "./envelope.js";
+export const systemHealthTool = {
+    name: "system.health",
+    description: "Check health of all 3 products (Vibe PM, Musu Engine, HiveLink) — signal: GO/FIX/BLOCK",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    handler: async () => {
+        const products = [];
+        // 1. Vibe PM — always up (we ARE the MCP server)
+        products.push({ product: "Vibe PM", status: "up", detail: "MCP server running locally" });
+        // 2. Musu Prime
+        if (!isPrimeConfigured()) {
+            products.push({
+                product: "Musu Engine",
+                status: "not_configured",
+                detail: "MUSU_PRIME_URL not set",
+            });
+        }
+        else {
+            const primeUp = await isPrimeAvailable();
+            products.push({
+                product: "Musu Engine",
+                status: primeUp ? "up" : "down",
+                detail: primeUp ? "Prime API responding" : "Prime API unreachable",
+            });
+        }
+        // 3. HiveLink (check via gateway status)
+        let hiveStatus;
+        if (!isPrimeConfigured()) {
+            hiveStatus = {
+                product: "HiveLink",
+                status: "not_configured",
+                detail: "MUSU_PRIME_URL not set (gateway unavailable)",
+            };
+        }
+        else {
+            try {
+                const gw = await primeGet("/v1/gateway/status");
+                const hasNodes = gw.data.total_nodes > 0;
+                hiveStatus = {
+                    product: "HiveLink",
+                    status: hasNodes ? "up" : "down",
+                    detail: hasNodes
+                        ? `${gw.data.total_nodes} node(s) connected via gateway`
+                        : "No HiveLink nodes registered in gateway",
+                };
+            }
+            catch {
+                hiveStatus = {
+                    product: "HiveLink",
+                    status: "down",
+                    detail: "Gateway unreachable",
+                };
+            }
+        }
+        products.push(hiveStatus);
+        // Compute signal
+        const upCount = products.filter((p) => p.status === "up").length;
+        const total = products.length;
+        let signal;
+        let summary;
+        if (upCount === total) {
+            signal = "GO";
+            summary = "All 3 products operational.";
+        }
+        else if (upCount === 0) {
+            signal = "BLOCK";
+            summary = "All products down or not configured.";
+        }
+        else {
+            signal = "FIX";
+            const downNames = products
+                .filter((p) => p.status !== "up")
+                .map((p) => p.product)
+                .join(", ");
+            summary = `${upCount}/${total} products up. Down: ${downNames}.`;
+        }
+        const data = { products, up_count: upCount, total };
+        const next = signal === "GO"
+            ? nextDone("System healthy.")
+            : nextToolCall("system.discover", "See which tools are available despite partial outage");
+        const envelope = wrapResponse(signal, data, summary, next);
+        return {
+            content: [{ type: "text", text: renderForHuman(envelope) }],
+            _ai_native: envelope,
+        };
+    },
+};

package/build/mcp/ai-native/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AI-Native module — universal response envelope, helpers, and system tools.
+ */
+export { type Signal, type NextAction, type AiNativeResponse, wrapResponse, infoResponse, goResponse, fixResponse, blockResponse, waitResponse, nextToolCall, nextUserPrompt, nextDone, renderForHuman, } from "./envelope.js";
+export { AFTER_BRIEFING, AFTER_SUBMIT_DECISION, AFTER_WORK_ORDER, VERDICT_GO, VERDICT_FIX, VERDICT_BLOCK, afterGetDecision, fromLegacy, signalFromReviewResult, nextActionForVerdict, } from "./next_action.js";
+export { systemDiscoverTool } from "./discover.js";
+export { systemHealthTool } from "./health.js";

package/build/mcp/ai-native/index.js

@@ -0,0 +1,7 @@
+/**
+ * AI-Native module — universal response envelope, helpers, and system tools.
+ */
+export { wrapResponse, infoResponse, goResponse, fixResponse, blockResponse, waitResponse, nextToolCall, nextUserPrompt, nextDone, renderForHuman, } from "./envelope.js";
+export { AFTER_BRIEFING, AFTER_SUBMIT_DECISION, AFTER_WORK_ORDER, VERDICT_GO, VERDICT_FIX, VERDICT_BLOCK, afterGetDecision, fromLegacy, signalFromReviewResult, nextActionForVerdict, } from "./next_action.js";
+export { systemDiscoverTool } from "./discover.js";
+export { systemHealthTool } from "./health.js";

package/build/mcp/ai-native/next_action.d.ts

@@ -0,0 +1,53 @@
+/**
+ * AI-Native NextAction Builder Utilities
+ *
+ * Reusable builders for the `next_action` field in AI-Native responses.
+ * These can be used by any tool — existing vibe_pm tools, musu bridge, hive bridge, etc.
+ *
+ * Existing tools already have next_action in various legacy formats:
+ * - { tool, label, reason }
+ * - { action_type: 'CONTINUE' | 'DONE' | 'ASK_DECISION', ... }
+ * - UnifiedNextAction { type: 'CALL_TOOL' | 'COPY_PASTE' | 'DONE', ... }
+ *
+ * This module provides the AI-Native standardized format + conversion helpers.
+ */
+import type { NextAction } from "./envelope.js";
+/** After briefing → get_decision */
+export declare const AFTER_BRIEFING: NextAction;
+/** After get_decision → submit_decision */
+export declare function afterGetDecision(choices: string[]): NextAction;
+/** After submit_decision → create_work_order */
+export declare const AFTER_SUBMIT_DECISION: NextAction;
+/** After create_work_order → implement → inspect_code */
+export declare const AFTER_WORK_ORDER: NextAction;
+/** GO verdict — done */
+export declare const VERDICT_GO: NextAction;
+/** FIX verdict — fix and re-inspect */
+export declare const VERDICT_FIX: NextAction;
+/** BLOCK verdict — go back to decision */
+export declare const VERDICT_BLOCK: NextAction;
+interface LegacyNextAction {
+    tool?: string;
+    label?: string;
+    reason?: string;
+    action_type?: string;
+    type?: string;
+    _tool?: string;
+    prompt_block?: string;
+    message?: string;
+}
+/**
+ * Convert a legacy next_action object to the AI-Native format.
+ * Handles all existing formats found in vibe_pm tools.
+ */
+export declare function fromLegacy(legacy: LegacyNextAction | null | undefined): NextAction;
+import type { Signal } from "./envelope.js";
+/**
+ * Convert a ReviewResult ('GO'|'FIX'|'BLOCK') to an AI-Native Signal.
+ */
+export declare function signalFromReviewResult(result: string): Signal;
+/**
+ * Get the standard next_action for a given review verdict.
+ */
+export declare function nextActionForVerdict(verdict: string): NextAction;
+export {};

package/build/mcp/ai-native/next_action.js

@@ -0,0 +1,133 @@
+/**
+ * AI-Native NextAction Builder Utilities
+ *
+ * Reusable builders for the `next_action` field in AI-Native responses.
+ * These can be used by any tool — existing vibe_pm tools, musu bridge, hive bridge, etc.
+ *
+ * Existing tools already have next_action in various legacy formats:
+ * - { tool, label, reason }
+ * - { action_type: 'CONTINUE' | 'DONE' | 'ASK_DECISION', ... }
+ * - UnifiedNextAction { type: 'CALL_TOOL' | 'COPY_PASTE' | 'DONE', ... }
+ *
+ * This module provides the AI-Native standardized format + conversion helpers.
+ */
+// ── Standard workflow next actions ────────────────────────────────────────────
+/** After briefing → get_decision */
+export const AFTER_BRIEFING = {
+    type: "tool_call",
+    tool: "vibe_pm.get_decision",
+    description: "Review the decision options before proceeding.",
+};
+/** After get_decision → submit_decision */
+export function afterGetDecision(choices) {
+    return {
+        type: "user_prompt",
+        question: "Choose an implementation approach:",
+        choices,
+    };
+}
+/** After submit_decision → create_work_order */
+export const AFTER_SUBMIT_DECISION = {
+    type: "tool_call",
+    tool: "vibe_pm.create_work_order",
+    description: "Generate the work order for implementation.",
+};
+/** After create_work_order → implement → inspect_code */
+export const AFTER_WORK_ORDER = {
+    type: "tool_call",
+    tool: "vibe_pm.inspect_code",
+    args: { mode: "thorough" },
+    description: "Implement the changes, then run code inspection.",
+};
+/** GO verdict — done */
+export const VERDICT_GO = {
+    type: "done",
+    description: "All checks passed. Work complete.",
+};
+/** FIX verdict — fix and re-inspect */
+export const VERDICT_FIX = {
+    type: "tool_call",
+    tool: "vibe_pm.inspect_code",
+    description: "Fix the reported issues, then re-inspect.",
+};
+/** BLOCK verdict — go back to decision */
+export const VERDICT_BLOCK = {
+    type: "tool_call",
+    tool: "vibe_pm.get_decision",
+    description: "Critical violation. Return to decision step.",
+};
+/**
+ * Convert a legacy next_action object to the AI-Native format.
+ * Handles all existing formats found in vibe_pm tools.
+ */
+export function fromLegacy(legacy) {
+    if (!legacy) {
+        return { type: "done", description: "No further action specified." };
+    }
+    // UnifiedNextAction format: { type: 'CALL_TOOL' | 'DONE' | 'COPY_PASTE', ... }
+    if (legacy.type === "CALL_TOOL" || legacy.type === "CONTINUE") {
+        return {
+            type: "tool_call",
+            tool: legacy._tool ?? legacy.tool ?? "unknown",
+            description: legacy.reason ?? legacy.label ?? "",
+        };
+    }
+    if (legacy.type === "DONE") {
+        return { type: "done", description: legacy.reason ?? legacy.label ?? legacy.message ?? "" };
+    }
+    if (legacy.type === "COPY_PASTE") {
+        return { type: "done", description: legacy.label ?? "Copy the provided block to your agent." };
+    }
+    // Old NextAction format: { action_type: 'CONTINUE' | 'DONE' | 'ASK_DECISION' | 'COPY_PASTE_TO_AGENT' }
+    if (legacy.action_type === "CONTINUE") {
+        return {
+            type: "tool_call",
+            tool: legacy.tool ?? "unknown",
+            description: legacy.reason ?? "",
+        };
+    }
+    if (legacy.action_type === "ASK_DECISION") {
+        return {
+            type: "tool_call",
+            tool: legacy.tool ?? "vibe_pm.get_decision",
+            description: legacy.reason ?? "A decision is needed.",
+        };
+    }
+    if (legacy.action_type === "DONE") {
+        return { type: "done", description: legacy.message ?? "" };
+    }
+    if (legacy.action_type === "COPY_PASTE_TO_AGENT") {
+        return { type: "done", description: legacy.label ?? "Copy the block to your agent." };
+    }
+    // Simple { tool, label/reason } format
+    if (legacy.tool) {
+        return {
+            type: "tool_call",
+            tool: legacy.tool,
+            description: legacy.reason ?? legacy.label ?? "",
+        };
+    }
+    return { type: "done", description: legacy.label ?? legacy.reason ?? "" };
+}
+/**
+ * Convert a ReviewResult ('GO'|'FIX'|'BLOCK') to an AI-Native Signal.
+ */
+export function signalFromReviewResult(result) {
+    switch (result) {
+        case "GO": return "GO";
+        case "FIX": return "FIX";
+        case "BLOCK": return "BLOCK";
+        default: return "INFO";
+    }
+}
+/**
+ * Get the standard next_action for a given review verdict.
+ */
+export function nextActionForVerdict(verdict) {
+    switch (verdict) {
+        case "GO": return VERDICT_GO;
+        case "FIX": return VERDICT_FIX;
+        case "BLOCK": return VERDICT_BLOCK;
+        default: return { type: "done", description: "Unknown verdict." };
+    }
+}

package/build/mcp/airlock/policy.d.ts

@@ -1,10 +1,10 @@
-import { AirlockPolicy } from "./types.js";
+import { AirlockPolicy } from './types.js';
 export declare function getAirlockPolicyPath(workspaceRoot: string): string;
 export declare function loadAirlockPolicy(workspaceRoot: string): {
     policy: AirlockPolicy;
     sha256: string;
     absPath: string;
-    source: "file" | "default";
+    source: 'file' | 'default';
     validation: {
         ok: true;
     } | {

package/build/mcp/airlock/policy.js

@@ -1,18 +1,18 @@
-import * as path from "node:path";
-import { getVibeConfigDir } from "../paths.js";
-import { AirlockPolicySchema } from "../policy/schema.js";
-import { loadJsonPolicy } from "../policy/loader.js";
+import * as path from 'node:path';
+import { getVibeConfigDir } from '../../kernel/paths.js';
+import { AirlockPolicySchema } from '../policy/schema.js';
+import { loadJsonPolicy } from '../policy/loader.js';
 export function getAirlockPolicyPath(workspaceRoot) {
     const override = process.env.AIRLOCK_POLICY_PATH?.trim();
     if (override) {
         return path.isAbsolute(override) ? override : path.join(workspaceRoot, override);
     }
-    return path.join(getVibeConfigDir(workspaceRoot), "airlock_policy.v1.json");
+    return path.join(getVibeConfigDir(workspaceRoot), 'airlock_policy.v1.json');
 }
 export function loadAirlockPolicy(workspaceRoot) {
     const absPath = getAirlockPolicyPath(workspaceRoot);
     const defaultPolicy = {
-        schema_version: "airlock_policy.v1",
+        schema_version: 'airlock_policy.v1',
         enabled: false,
         rules: [],
     };

package/build/mcp/airlock/report.d.ts

@@ -1,4 +1,4 @@
-import { AirlockFingerprint, AirlockReport } from "./types.js";
+import { AirlockFingerprint, AirlockReport } from './types.js';
 export declare function writeAirlockArtifacts(params: {
     workspaceRoot: string;
     runId: string;

package/build/mcp/airlock/report.js

@@ -1,52 +1,52 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as crypto from "node:crypto";
-import { ensureDirSync, getPmRunDir } from "../paths.js";
-import { emitEvent } from "../events/emitter.js";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { ensureDirSync, getPmRunDir } from '../../kernel/paths.js';
+import { emitEvent } from '../events/emitter.js';
 export function writeAirlockArtifacts(params) {
     const runDir = getPmRunDir(params.workspaceRoot, params.runId);
-    const airlockDir = path.join(runDir, "airlock");
+    const airlockDir = path.join(runDir, 'airlock');
     ensureDirSync(airlockDir);
-    const reportPath = path.join(airlockDir, "redaction_report.json");
-    const safeContextPath = path.join(airlockDir, "safe_context.txt");
-    const fingerprintPath = path.join(airlockDir, "input_fingerprint.json");
-    const rawSha = crypto.createHash("sha256").update(params.rawText).digest("hex");
+    const reportPath = path.join(airlockDir, 'redaction_report.json');
+    const safeContextPath = path.join(airlockDir, 'safe_context.txt');
+    const fingerprintPath = path.join(airlockDir, 'input_fingerprint.json');
+    const rawSha = crypto.createHash('sha256').update(params.rawText).digest('hex');
     const fingerprint = {
-        schema_version: "airlock_input.v1",
+        schema_version: 'airlock_input.v1',
         run_id: params.runId,
         raw_sha256: rawSha,
         policy_sha256: params.policySha256,
-        bytes: Buffer.byteLength(params.rawText, "utf8"),
+        bytes: Buffer.byteLength(params.rawText, 'utf8'),
         created_at: new Date().toISOString(),
     };
     fs.writeFileSync(reportPath, JSON.stringify(params.report, null, 2));
-    fs.writeFileSync(safeContextPath, params.safeText, "utf8");
+    fs.writeFileSync(safeContextPath, params.safeText, 'utf8');
     fs.writeFileSync(fingerprintPath, JSON.stringify(fingerprint, null, 2));
     emitEvent({
         runId: params.runId,
-        type: "artifact.airlock_report_written",
-        reason: "airlock_report_written",
+        type: 'artifact.airlock_report_written',
+        reason: 'airlock_report_written',
         paths: [reportPath],
-        component: "airlock",
-        actor: "engine",
+        component: 'airlock',
+        actor: 'engine',
         workspaceRoot: params.workspaceRoot,
     });
     emitEvent({
         runId: params.runId,
-        type: "artifact.airlock_safe_context_written",
-        reason: "airlock_safe_context_written",
+        type: 'artifact.airlock_safe_context_written',
+        reason: 'airlock_safe_context_written',
         paths: [safeContextPath],
-        component: "airlock",
-        actor: "engine",
+        component: 'airlock',
+        actor: 'engine',
         workspaceRoot: params.workspaceRoot,
     });
     emitEvent({
         runId: params.runId,
-        type: "artifact.airlock_fingerprint_written",
-        reason: "airlock_fingerprint_written",
+        type: 'artifact.airlock_fingerprint_written',
+        reason: 'airlock_fingerprint_written',
         paths: [fingerprintPath],
-        component: "airlock",
-        actor: "engine",
+        component: 'airlock',
+        actor: 'engine',
         workspaceRoot: params.workspaceRoot,
     });
     return { reportPath, fingerprintPath, safeContextPath, fingerprint };

package/build/mcp/auth/token_cache.js

@@ -1,3 +1,4 @@
+import { logger } from '../../shared/logger.js';
 import { homedir } from 'os';
 import { join } from 'path';
 import { readFile, writeFile, mkdir } from 'fs/promises';
@@ -95,7 +96,7 @@ export class TokenCache {
             await writeFile(this.resolveTokenFilePath(), data, { mode: 0o600 });
         }
         catch (error) {
-            console.error('Failed to save token to disk:', error);
+            logger.error({ err: error }, 'Failed to save token to disk');
         }
     }
     /**

package/build/mcp/bootstrap/doctor.js

@@ -22,7 +22,7 @@ function buildSkillGates(skillsHealth) {
         gates.push({
             code: "SKILL_INDEX_INVALID",
             severity: "FAIL",
-            message: "Skills index.json not found or invalid"
+            message: "스킬 인덱스가 손상되었습니다. 재설치하거나 VIBECODE_OFFLINE=1로 오프라인 모드를 사용하세요."
         });
         return gates;
     }
@@ -104,7 +104,7 @@ export async function doctor() {
             corrupted: healthAfter.filter((h) => h.status === "corrupted").length
         };
         // Check skills health
-        const skillsHealth = getSkillsHealth();
+        const skillsHealth = await getSkillsHealth();
         const skillGates = buildSkillGates(skillsHealth);
         // Determine skill status
         let skillStatus = "OK";
@@ -168,7 +168,7 @@ export async function doctor() {
  */
 export async function healthCheck() {
     const health = await getEngineHealth();
-    const skillsHealth = getSkillsHealth();
+    const skillsHealth = await getSkillsHealth();
     const engineOk = health.every((h) => h.status === "ok");
     const skillsOk = skillsHealth.installed &&
         skillsHealth.summary.missing === 0 &&

package/build/mcp/bootstrap/installer.d.ts

@@ -1,37 +1,22 @@
 import { type EngineName } from "./registry.js";
 export type { EngineName };
+export { cacheRoot, isDebugMode, isOfflineMode, getGitHubToken, getAuthHeaders, engineDir, versionFile, parseSearchPaths, makeBootstrapError, userMessageForBootstrapFailure, } from "./installer_env.js";
+export { sha256File, sleep, fetchWithRetry, download, releaseBaseUrl, readShaSums, readShaSumsFromUrl, discoverRelease, findAsset, downloadAsset, extractTarGz, makeExecutable, type GhAsset, type GhRelease, } from "./installer_network.js";
+export { getCurrentVersion, setCurrentVersion, needsUpdate, checkUpdates, parseEngineVersionFromAsset, discoverLatestEnginesRelease, extractEngineVersionsFromRelease, checkRemoteUpdates, type RemoteUpdateInfo, type RemoteEngineVersion, } from "./installer_version.js";
 export type EnginePaths = Record<EngineName, string>;
 /**
- * Get platform-appropriate cache root directory
- */
-export declare function cacheRoot(): string;
-/**
- * Check if engine needs update
- */
-export declare function needsUpdate(name: EngineName): Promise<boolean>;
-/**
- * Check all engines for updates
+ * Ensure all engines are installed and return their paths
+ * Thread-safe via file lock
+ * Self-healing: validates cache, auto-updates, retries on failure
  */
-export declare function checkUpdates(): Promise<Record<EngineName, {
-    current: string | null;
-    required: string;
-    needsUpdate: boolean;
-}>>;
-export interface RemoteUpdateInfo {
-    available: boolean;
-    engines: {
-        name: EngineName;
-        currentVersion: string | null;
-        remoteVersion: string;
-        needsUpdate: boolean;
-    }[];
-    releaseTag: string | null;
-}
+export declare function ensureEngines(): Promise<EnginePaths>;
 /**
- * Check for remote updates from GitHub Releases
- * This allows updates without npm package update
+ * Ensure a single engine is installed and return its resolved binary path.
+ * Thread-safe via per-engine lock.
+ *
+ * This is the primitive used by JIT acquisition (P3).
  */
-export declare function checkRemoteUpdates(): Promise<RemoteUpdateInfo>;
+export declare function ensureEngine(name: EngineName): Promise<string>;
 /**
  * Update engines from remote release (ignoring registry.ts versions)
  */
@@ -54,12 +39,6 @@ export declare function clearCache(name: EngineName): Promise<void>;
  * Clear all engine caches
  */
 export declare function clearAllCaches(): Promise<void>;
-/**
- * Ensure all engines are installed and return their paths
- * Thread-safe via file lock
- * Self-healing: validates cache, auto-updates, retries on failure
- */
-export declare function ensureEngines(): Promise<EnginePaths>;
 export interface EngineHealth {
     name: EngineName;
     version: string;