@vibecodetown/mcp-server 2.1.4 → 2.2.1

package/build/bootstrap/skills-installer.js

@@ -0,0 +1,365 @@
+// adapters/mcp-ts/src/bootstrap/skills-installer.ts
+// Skill bundle installation, activation, and health check
+// Skills are prebundled in the npm package (no network required)
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { SKILL_SPEC } from "./registry.js";
+// ============================================================
+// Path Utilities
+// ============================================================
+/**
+ * Find package root by looking for package.json
+ */
+function findPackageRoot() {
+    // Start from current module's directory
+    let dir = path.dirname(new URL(import.meta.url).pathname);
+    // On Windows, remove leading slash from /C:/...
+    if (process.platform === "win32" && dir.startsWith("/")) {
+        dir = dir.slice(1);
+    }
+    for (let i = 0; i < 10; i++) {
+        const pkgPath = path.join(dir, "package.json");
+        try {
+            if (fs.existsSync(pkgPath)) {
+                return dir;
+            }
+        }
+        catch {
+            // ignore
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Get the path to the prebundled skills directory in the npm package
+ */
+export function getSkillsBundlePath() {
+    const pkgRoot = findPackageRoot();
+    if (!pkgRoot)
+        return null;
+    const skillsDir = path.join(pkgRoot, SKILL_SPEC.bundlePath);
+    try {
+        if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
+            return skillsDir;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/**
+ * Get the path to the project's .vibe/skills/ directory
+ */
+export function getProjectSkillsPath(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return path.join(root, ".vibe", "skills");
+}
+// ============================================================
+// Index Loading
+// ============================================================
+/**
+ * Load the skills index from the prebundled directory
+ */
+export function loadSkillsIndex() {
+    const bundlePath = getSkillsBundlePath();
+    if (!bundlePath)
+        return null;
+    const indexPath = path.join(bundlePath, "index.json");
+    try {
+        const content = fs.readFileSync(indexPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load the activated skills index from the project
+ */
+export function loadActivatedSkillsIndex(projectRoot) {
+    const skillsPath = getProjectSkillsPath(projectRoot);
+    const indexPath = path.join(skillsPath, "index.json");
+    try {
+        const content = fs.readFileSync(indexPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================
+// Health Check
+// ============================================================
+/**
+ * Calculate SHA256 hash of a file
+ */
+function calculateSha256(filePath) {
+    try {
+        const content = fs.readFileSync(filePath);
+        return crypto.createHash("sha256").update(content).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check health of a single skill in the bundle
+ */
+function checkSkillHealth(bundlePath, skill) {
+    const filePath = path.join(bundlePath, skill.file);
+    if (!fs.existsSync(filePath)) {
+        return {
+            id: skill.id,
+            status: "missing",
+            version: skill.version,
+            path: null,
+            error: `Skill file not found: ${skill.file}`
+        };
+    }
+    const actualSha = calculateSha256(filePath);
+    if (!actualSha) {
+        return {
+            id: skill.id,
+            status: "sha_mismatch",
+            version: skill.version,
+            path: filePath,
+            error: "Failed to calculate SHA256"
+        };
+    }
+    if (actualSha !== skill.sha256) {
+        return {
+            id: skill.id,
+            status: "sha_mismatch",
+            version: skill.version,
+            path: filePath,
+            error: `SHA256 mismatch: expected ${skill.sha256}, got ${actualSha}`
+        };
+    }
+    return {
+        id: skill.id,
+        status: "ok",
+        version: skill.version,
+        path: filePath
+    };
+}
+/**
+ * Check health of the entire skills bundle
+ */
+export function getSkillsHealth() {
+    const bundlePath = getSkillsBundlePath();
+    if (!bundlePath) {
+        return {
+            installed: false,
+            bundlePath: null,
+            version: null,
+            skills: [],
+            summary: { total: 0, ok: 0, missing: 0, corrupted: 0 }
+        };
+    }
+    const index = loadSkillsIndex();
+    if (!index) {
+        return {
+            installed: true,
+            bundlePath,
+            version: null,
+            skills: [],
+            summary: { total: 0, ok: 0, missing: 0, corrupted: 0 }
+        };
+    }
+    const skills = index.skills.map(skill => checkSkillHealth(bundlePath, skill));
+    const summary = {
+        total: skills.length,
+        ok: skills.filter(s => s.status === "ok").length,
+        missing: skills.filter(s => s.status === "missing").length,
+        corrupted: skills.filter(s => s.status === "sha_mismatch").length
+    };
+    return {
+        installed: true,
+        bundlePath,
+        version: index.version,
+        skills,
+        summary
+    };
+}
+// ============================================================
+// Skill Listing
+// ============================================================
+/**
+ * List all available skills from the prebundled directory
+ */
+export function listAvailableSkills() {
+    const index = loadSkillsIndex();
+    return index?.skills ?? [];
+}
+/**
+ * List activated skills in the project
+ */
+export function listActivatedSkills(projectRoot) {
+    const index = loadActivatedSkillsIndex(projectRoot);
+    return index?.activated ?? [];
+}
+/**
+ * Get skill metadata by ID
+ */
+export function getSkillById(skillId) {
+    const skills = listAvailableSkills();
+    return skills.find(s => s.id === skillId) ?? null;
+}
+// ============================================================
+// Skill Activation
+// ============================================================
+/**
+ * Activate skills for a project by copying them to .vibe/skills/
+ */
+export async function activateSkills(projectRoot, skillIds) {
+    const bundlePath = getSkillsBundlePath();
+    if (!bundlePath) {
+        return { activated: [], errors: ["Skill bundle not found in package"] };
+    }
+    const index = loadSkillsIndex();
+    if (!index) {
+        return { activated: [], errors: ["Skills index not found or invalid"] };
+    }
+    // If no skillIds specified, activate all
+    const toActivate = skillIds ?? index.skills.map(s => s.id);
+    const skillsToActivate = toActivate
+        .map(id => index.skills.find(s => s.id === id))
+        .filter((s) => s !== undefined);
+    if (skillsToActivate.length === 0) {
+        return { activated: [], errors: ["No valid skills to activate"] };
+    }
+    const projectSkillsPath = getProjectSkillsPath(projectRoot);
+    // Ensure .vibe/skills/ directory exists
+    try {
+        await fs.promises.mkdir(projectSkillsPath, { recursive: true });
+    }
+    catch (e) {
+        return {
+            activated: [],
+            errors: [`Failed to create skills directory: ${e instanceof Error ? e.message : String(e)}`]
+        };
+    }
+    const activated = [];
+    const errors = [];
+    // Copy each skill file
+    for (const skill of skillsToActivate) {
+        const srcPath = path.join(bundlePath, skill.file);
+        const destPath = path.join(projectSkillsPath, skill.file);
+        try {
+            await fs.promises.copyFile(srcPath, destPath);
+            activated.push(skill.id);
+        }
+        catch (e) {
+            errors.push(`Failed to copy ${skill.id}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    // Write the activated skills index
+    if (activated.length > 0) {
+        const activatedIndex = {
+            version: index.version,
+            activated,
+            activated_at: new Date().toISOString(),
+            source: "prebundled",
+            skills: skillsToActivate.filter(s => activated.includes(s.id))
+        };
+        const indexPath = path.join(projectSkillsPath, "index.json");
+        try {
+            await fs.promises.writeFile(indexPath, JSON.stringify(activatedIndex, null, 2), "utf-8");
+        }
+        catch (e) {
+            errors.push(`Failed to write index.json: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { activated, errors };
+}
+/**
+ * Deactivate a skill from the project
+ */
+export async function deactivateSkill(projectRoot, skillId) {
+    const projectSkillsPath = getProjectSkillsPath(projectRoot);
+    const activatedIndex = loadActivatedSkillsIndex(projectRoot);
+    if (!activatedIndex) {
+        return { success: false, error: "No activated skills found" };
+    }
+    const skillMeta = activatedIndex.skills.find(s => s.id === skillId);
+    if (!skillMeta) {
+        return { success: false, error: `Skill ${skillId} is not activated` };
+    }
+    // Remove the skill file
+    const skillPath = path.join(projectSkillsPath, skillMeta.file);
+    try {
+        if (fs.existsSync(skillPath)) {
+            await fs.promises.unlink(skillPath);
+        }
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: `Failed to remove skill file: ${e instanceof Error ? e.message : String(e)}`
+        };
+    }
+    // Update the index
+    const newActivated = activatedIndex.activated.filter(id => id !== skillId);
+    const newSkills = activatedIndex.skills.filter(s => s.id !== skillId);
+    if (newActivated.length === 0) {
+        // Remove the index file if no skills remain
+        const indexPath = path.join(projectSkillsPath, "index.json");
+        try {
+            await fs.promises.unlink(indexPath);
+        }
+        catch {
+            // ignore
+        }
+    }
+    else {
+        // Update the index
+        const updatedIndex = {
+            ...activatedIndex,
+            activated: newActivated,
+            skills: newSkills
+        };
+        const indexPath = path.join(projectSkillsPath, "index.json");
+        await fs.promises.writeFile(indexPath, JSON.stringify(updatedIndex, null, 2), "utf-8");
+    }
+    return { success: true };
+}
+// ============================================================
+// Ensure Skills (for setup/update)
+// ============================================================
+/**
+ * Ensure skills are installed and healthy
+ * Returns the bundle path if successful
+ */
+export function ensureSkills() {
+    const health = getSkillsHealth();
+    // For prebundled skills, we can't "repair" - they're part of the package
+    // If they're corrupted, the user needs to reinstall the package
+    return {
+        path: health.bundlePath,
+        health
+    };
+}
+/**
+ * Get skill content by ID
+ */
+export function getSkillContent(skillId) {
+    const bundlePath = getSkillsBundlePath();
+    if (!bundlePath)
+        return null;
+    const skill = getSkillById(skillId);
+    if (!skill)
+        return null;
+    const filePath = path.join(bundlePath, skill.file);
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}

package/build/control_plane/gate.js

@@ -3,8 +3,10 @@
  *
  * Provides gate enforcement for work orders before execution.
  * All work orders must pass through the gate before any work can proceed.
+ *
+ * All subprocess invocations go through cli_invoker for centralized management.
  */
-import { spawn } from "child_process";
+import { invokeSystem } from "../runtime/cli_invoker.js";
 import { WorkOrderV1Schema } from "../generated/work_order_v1.js";
 import { GateResultV1Schema } from "../generated/gate_result_v1.js";
 /**
@@ -30,76 +32,56 @@ export async function runSystemDesignGate(workOrder, options) {
     pushBool("fail-fast", options.failFast);
     pushBool("semgrep", options.semgrep);
     pushBool("runtime", options.runtime);
-    return new Promise((resolve) => {
-        const child = spawn(pythonExe, [
-            "-m",
-            "vibecoding_helper",
-            "--repo-root",
-            repoRoot,
-            "gate-check",
-            ...overrideFlags,
-            "--work-order",
-            workOrderJson,
-            "--format",
-            "json",
-        ], {
-            cwd: repoRoot,
-            timeout: timeoutMs,
-            env: { ...process.env, PYTHONIOENCODING: "utf-8" },
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout?.on("data", (data) => {
-            stdout += data.toString();
-        });
-        child.stderr?.on("data", (data) => {
-            stderr += data.toString();
-        });
-        child.on("close", (code) => {
-            // Exit code 0 = ALLOW, 2 = BLOCK, other = error
-            if (code === null) {
-                resolve({
-                    success: false,
-                    error: "Gate check timed out",
-                });
-                return;
-            }
-            if (code !== 0 && code !== 2) {
-                resolve({
-                    success: false,
-                    error: `Gate check failed with code ${code}: ${stderr || stdout}`,
-                });
-                return;
-            }
-            try {
-                const result = JSON.parse(stdout.trim());
-                const validated = GateResultV1Schema.safeParse(result);
-                if (!validated.success) {
-                    resolve({
-                        success: false,
-                        error: `Invalid gate result: ${validated.error.message}`,
-                    });
-                    return;
-                }
-                resolve({
-                    success: true,
-                    result: validated.data,
-                });
-            }
-            catch (e) {
-                resolve({
-                    success: false,
-                    error: `Failed to parse gate result: ${e instanceof Error ? e.message : String(e)}`,
-                });
-            }
-        });
-        child.on("error", (err) => {
-            resolve({
-                success: false,
-                error: `Gate check process error: ${err.message}`,
-            });
-        });
+    const args = [
+        "-m",
+        "vibecoding_helper",
+        "--repo-root",
+        repoRoot,
+        "gate-check",
+        ...overrideFlags,
+        "--work-order",
+        workOrderJson,
+        "--format",
+        "json",
+    ];
+    const result = await invokeSystem(pythonExe, args, repoRoot, {
+        env: { PYTHONIOENCODING: "utf-8" },
+        timeoutMs,
     });
+    // Exit code 124 = timeout
+    if (result.exitCode === 124) {
+        return {
+            success: false,
+            error: "Gate check timed out",
+        };
+    }
+    // Exit code 0 = ALLOW, 2 = BLOCK, other = error
+    if (result.exitCode !== 0 && result.exitCode !== 2) {
+        return {
+            success: false,
+            error: `Gate check failed with code ${result.exitCode}: ${result.stderr || result.stdout}`,
+        };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout.trim());
+        const validated = GateResultV1Schema.safeParse(parsed);
+        if (!validated.success) {
+            return {
+                success: false,
+                error: `Invalid gate result: ${validated.error.message}`,
+            };
+        }
+        return {
+            success: true,
+            result: validated.data,
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: `Failed to parse gate result: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
 }
 /**
  * Execute a work order only if it passes the gate

package/build/dx/activity.js

@@ -1,5 +1,6 @@
 // adapters/mcp-ts/src/dx/activity.ts
 // Activity/DX helpers: branded header, status icons, optional desktop notifications
+import { getWaiterMapping, renderVerdictFromTemplateId, resolveLocaleFromData } from "../tools/vibe_pm/waiter_mapping.js";
 function boolEnv(name, defaultValue) {
     const raw = (process.env[name] ?? "").trim().toLowerCase();
     if (!raw)
@@ -91,14 +92,35 @@ function verdictIcon(data, outcome) {
     }
     return "✅";
 }
+function verdictLabel(data, outcome) {
+    if (outcome === "error")
+        return "";
+    if (!data || typeof data !== "object")
+        return "";
+    const obj = data;
+    const templateId = typeof obj.message_template_id === "string" ? String(obj.message_template_id) : "";
+    if (!templateId)
+        return "";
+    try {
+        const mapping = getWaiterMapping();
+        const locale = resolveLocaleFromData(data, mapping);
+        const label = renderVerdictFromTemplateId(templateId, locale, mapping);
+        return label ? label : "";
+    }
+    catch {
+        return "";
+    }
+}
 export function renderActivityHeader(toolName, data, outcome = "success", durationMs) {
     const badge = toolBadge(toolName, data);
     const status = verdictIcon(data, outcome);
+    const label = verdictLabel(data, outcome);
     const duration = typeof durationMs === "number" && durationMs >= 0 ? ` · ${Math.round(durationMs)}ms` : "";
+    const verdict = label ? ` · ${label}` : "";
     return [
         "╭──────────────────────────────╮",
         "│  VibePM ⚡️ Active            │",
-        `│  ${status} ${badge.icon} ${badge.label}${duration}`,
+        `│  ${status} ${badge.icon} ${badge.label}${verdict}${duration}`,
         "╰──────────────────────────────╯"
     ].join("\n");
 }
@@ -107,9 +129,10 @@ export function decorateToolOutputText(toolName, jsonText, data, outcome = "succ
         return [{ type: "text", text: jsonText }];
     }
     const header = renderActivityHeader(toolName, data, outcome, durationMs);
+    // Combine header and JSON into single block to ensure both are displayed
+    // (some MCP clients only show the first content block on error)
     return [
-        { type: "text", text: header },
-        { type: "text", text: jsonText }
+        { type: "text", text: header + "\n" + jsonText }
     ];
 }
 export async function notifyDesktopBestEffort(args) {