@vibecodetown/mcp-server 1.3.1

package/build/mcp/security/sandbox.js

@@ -0,0 +1,378 @@
+// adapters/mcp-ts/src/security/sandbox.ts
+// Optional container sandbox for production environments
+//
+// Note: This is an optional security layer. The primary security
+// is provided by input validation and path policy.
+//
+// v2.0: Migrated from Docker to Podman with CIDFILE pattern
+// - Fixes container kill logic bug (was killing CLI process, not container)
+// - Uses --cidfile for reliable container lifecycle management
+// - Podman is daemonless and rootless by default (better security)
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, unlinkSync, readFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Default sandbox configuration (no sandboxing)
+ */
+export const DEFAULT_SANDBOX_CONFIG = {
+    mode: "none",
+    allowedPaths: [],
+    networkAccess: false,
+    memoryLimitMb: 512,
+    cpuLimit: 1,
+    timeoutMs: 120_000,
+};
+/**
+ * Check if Podman is available on the system (recommended)
+ */
+export async function isPodmanAvailable() {
+    return new Promise((resolve) => {
+        const proc = spawn("podman", ["version"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        proc.on("error", () => resolve(false));
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+/**
+ * Check if Docker is available on the system
+ * @deprecated Use isPodmanAvailable instead - Docker has container kill bugs
+ */
+export async function isDockerAvailable() {
+    return new Promise((resolve) => {
+        const proc = spawn("docker", ["version"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        proc.on("error", () => resolve(false));
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+/**
+ * Check if firejail is available on the system
+ */
+export async function isFirejailAvailable() {
+    return new Promise((resolve) => {
+        const proc = spawn("firejail", ["--version"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        proc.on("error", () => resolve(false));
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+/**
+ * Run command in sandbox environment
+ *
+ * @param cmd - Command to execute
+ * @param args - Command arguments
+ * @param config - Sandbox configuration
+ * @returns Execution result
+ */
+export async function runInSandbox(cmd, args, config = DEFAULT_SANDBOX_CONFIG) {
+    switch (config.mode) {
+        case "podman":
+            return runInPodman(cmd, args, config);
+        case "docker":
+            // Deprecated: Docker has container kill bugs, prefer Podman
+            console.warn("[SANDBOX] Docker mode is deprecated. Migrate to Podman for reliable container lifecycle.");
+            return runInDocker(cmd, args, config);
+        case "firejail":
+            return runInFirejail(cmd, args, config);
+        case "none":
+        default:
+            return runDirect(cmd, args, config);
+    }
+}
+/**
+ * Run command directly (no sandboxing)
+ */
+async function runDirect(cmd, args, config) {
+    return new Promise((resolve) => {
+        const proc = spawn(cmd, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = setTimeout(() => {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch { }
+            resolve({ code: 124, stdout, stderr: stderr + "\n[SANDBOX TIMEOUT]" });
+        }, config.timeoutMs);
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timeout);
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+/**
+ * Get or create CIDFILE directory for container ID files
+ */
+function getCidfileDir() {
+    const cidDir = join(tmpdir(), "vibe-sandbox-cid");
+    if (!existsSync(cidDir)) {
+        mkdirSync(cidDir, { recursive: true });
+    }
+    return cidDir;
+}
+/**
+ * Clean up container using CIDFILE
+ * Graceful stop first, then force kill if needed
+ */
+function cleanupContainerByCidfile(cidfile, runtime) {
+    if (!existsSync(cidfile))
+        return;
+    try {
+        const containerId = readFileSync(cidfile, "utf-8").trim();
+        if (!containerId)
+            return;
+        // Graceful stop (5s timeout)
+        spawnSync(runtime, ["stop", "-t", "5", containerId], {
+            stdio: "ignore",
+            timeout: 10_000,
+        });
+        // Force remove (cleanup)
+        spawnSync(runtime, ["rm", "-f", containerId], {
+            stdio: "ignore",
+            timeout: 5_000,
+        });
+    }
+    catch {
+        // Best effort cleanup
+    }
+    finally {
+        // Always remove cidfile
+        try {
+            unlinkSync(cidfile);
+        }
+        catch { }
+    }
+}
+/**
+ * Run command in Podman sandbox (RECOMMENDED)
+ *
+ * Uses CIDFILE pattern for reliable container lifecycle management:
+ * - --cidfile writes container ID to file on start
+ * - On timeout/cleanup, we read cidfile and stop the exact container
+ * - No more zombie containers from killing CLI process PID
+ *
+ * Requirements:
+ * - Podman must be installed
+ * - vibecode/sandbox:latest image must exist
+ */
+async function runInPodman(cmd, args, config) {
+    const runId = randomUUID().slice(0, 8);
+    const cidfile = join(getCidfileDir(), `vibe-sbx-${runId}.cid`);
+    const podmanArgs = [
+        "run",
+        "--rm",
+        // CIDFILE pattern - critical for proper cleanup
+        "--cidfile", cidfile,
+        "--name", `vibe-sbx-${runId}`,
+        // Network isolation
+        "--network", config.networkAccess ? "bridge" : "none",
+        // Resource limits
+        "--memory", `${config.memoryLimitMb}m`,
+        "--cpus", String(config.cpuLimit),
+        // Security options (Podman is rootless by default)
+        "--security-opt", "no-new-privileges:true",
+        "--cap-drop", "ALL",
+        // Read-only root filesystem
+        "--read-only",
+    ];
+    // Mount allowed paths as read-only volumes
+    for (const allowedPath of config.allowedPaths) {
+        podmanArgs.push("-v", `${allowedPath}:${allowedPath}:ro`);
+    }
+    // Add tmpfs for /tmp if needed
+    podmanArgs.push("--tmpfs", "/tmp:rw,noexec,nosuid,size=100m");
+    // Image and command
+    podmanArgs.push("vibecode/sandbox:latest", cmd, ...args);
+    return new Promise((resolve) => {
+        const proc = spawn("podman", podmanArgs, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let resolved = false;
+        const cleanup = () => {
+            if (!resolved) {
+                resolved = true;
+                // Always cleanup container via CIDFILE (not proc.pid!)
+                cleanupContainerByCidfile(cidfile, "podman");
+            }
+        };
+        const timeout = setTimeout(() => {
+            cleanup();
+            try {
+                proc.kill("SIGKILL"); // Kill CLI process after container cleanup
+            }
+            catch { }
+            resolve({ code: 124, stdout, stderr: stderr + "\n[PODMAN TIMEOUT]" });
+        }, config.timeoutMs);
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timeout);
+            cleanup();
+            resolve({ code: 127, stdout, stderr: stderr + `\n[SPAWN_ERROR] ${err.message}` });
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timeout);
+            cleanup();
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+/**
+ * Run command in Docker sandbox
+ * @deprecated Use runInPodman instead - Docker kill logic has bugs
+ *
+ * Requirements:
+ * - Docker must be installed and running
+ * - vibecode/sandbox:latest image must exist
+ */
+async function runInDocker(cmd, args, config) {
+    const dockerArgs = [
+        "run",
+        "--rm",
+        // Network isolation
+        "--network",
+        config.networkAccess ? "bridge" : "none",
+        // Resource limits
+        "--memory",
+        `${config.memoryLimitMb}m`,
+        "--cpus",
+        String(config.cpuLimit),
+        // Security options
+        "--security-opt",
+        "no-new-privileges:true",
+        "--cap-drop",
+        "ALL",
+        // Read-only root filesystem
+        "--read-only",
+    ];
+    // Mount allowed paths as read-only volumes
+    for (const allowedPath of config.allowedPaths) {
+        dockerArgs.push("-v", `${allowedPath}:${allowedPath}:ro`);
+    }
+    // Add tmpfs for /tmp if needed
+    dockerArgs.push("--tmpfs", "/tmp:rw,noexec,nosuid,size=100m");
+    // Image and command
+    dockerArgs.push("vibecode/sandbox:latest", cmd, ...args);
+    return new Promise((resolve) => {
+        const proc = spawn("docker", dockerArgs, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = setTimeout(() => {
+            try {
+                // Kill the docker container
+                spawn("docker", ["kill", proc.pid?.toString() ?? ""], {
+                    stdio: "ignore",
+                });
+                proc.kill("SIGKILL");
+            }
+            catch { }
+            resolve({ code: 124, stdout, stderr: stderr + "\n[DOCKER TIMEOUT]" });
+        }, config.timeoutMs);
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timeout);
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+/**
+ * Run command in firejail sandbox (Linux only)
+ *
+ * Requirements:
+ * - firejail must be installed
+ */
+async function runInFirejail(cmd, args, config) {
+    const firejailArgs = [
+        // Disable network if not allowed
+        ...(config.networkAccess ? [] : ["--net=none"]),
+        // Resource limits
+        "--rlimit-as=" + config.memoryLimitMb * 1024 * 1024,
+        // Security options
+        "--caps.drop=all",
+        "--nonewprivs",
+        "--seccomp",
+        // No X11
+        "--x11=none",
+        // Read-only paths
+        "--read-only=/",
+    ];
+    // Whitelist allowed paths
+    for (const allowedPath of config.allowedPaths) {
+        firejailArgs.push(`--whitelist=${allowedPath}`);
+    }
+    // Allow /tmp for temporary files
+    firejailArgs.push("--private-tmp");
+    // Command to run
+    firejailArgs.push("--", cmd, ...args);
+    return new Promise((resolve) => {
+        const proc = spawn("firejail", firejailArgs, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = setTimeout(() => {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch { }
+            resolve({ code: 124, stdout, stderr: stderr + "\n[FIREJAIL TIMEOUT]" });
+        }, config.timeoutMs);
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timeout);
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+/**
+ * Create sandbox configuration from environment
+ */
+export function getSandboxConfigFromEnv() {
+    const mode = (process.env.VIBECODE_SANDBOX_MODE ?? "none");
+    const networkAccess = process.env.VIBECODE_SANDBOX_NETWORK === "true";
+    const memoryLimitMb = parseInt(process.env.VIBECODE_SANDBOX_MEMORY ?? "512", 10);
+    const cpuLimit = parseFloat(process.env.VIBECODE_SANDBOX_CPU ?? "1");
+    const timeoutMs = parseInt(process.env.VIBECODE_SANDBOX_TIMEOUT ?? "120000", 10);
+    const allowedPaths = (process.env.VIBECODE_SANDBOX_PATHS ?? "")
+        .split(":")
+        .filter((p) => p.length > 0);
+    return {
+        mode,
+        allowedPaths,
+        networkAccess,
+        memoryLimitMb,
+        cpuLimit,
+        timeoutMs,
+    };
+}

package/build/mcp/tool-registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MCP Tool Registry SSOT:
+ * - "등록된 것만이 진실"을 유지하면서
+ * - server.tool()에 전달되는 schema 형태(.shape)가 SDK 변경에 취약하므로
+ *   테스트로 회귀 잠금하기 위해 registry를 함수로 추출한다.
+ *
+ * Profile Integration (v1.1.0):
+ * - VIBE_PROFILE 환경변수로 도구 필터링 가능
+ * - 기본값: "all" (모든 도구 로드)
+ * - 예: VIBE_PROFILE=mvp → 8개 핵심 도구만 로드
+ *
+ * Lazy Import (v1.2.0):
+ * - Profile 기반으로 필요한 모듈만 dynamic import
+ * - BitNet 도구가 비활성화된 profile에서는 해당 모듈 로드 스킵
+ */
+export type ToolSchemaArg = unknown;
+export type ToolRegistration = {
+    name: string;
+    desc: string;
+    schemaArg: ToolSchemaArg;
+};
+export type ToolRegistrySpy = {
+    tool: (name: string, desc: string, schemaArg: ToolSchemaArg, handler: unknown) => void;
+};
+export declare function registerAllTools(server: ToolRegistrySpy): Promise<void>;
+export declare function captureRegistrySnapshot(): Promise<ToolRegistration[]>;

package/build/mcp/tool-registry.js

@@ -0,0 +1,136 @@
+/**
+ * MCP Tool Registry SSOT:
+ * - "등록된 것만이 진실"을 유지하면서
+ * - server.tool()에 전달되는 schema 형태(.shape)가 SDK 변경에 취약하므로
+ *   테스트로 회귀 잠금하기 위해 registry를 함수로 추출한다.
+ *
+ * Profile Integration (v1.1.0):
+ * - VIBE_PROFILE 환경변수로 도구 필터링 가능
+ * - 기본값: "all" (모든 도구 로드)
+ * - 예: VIBE_PROFILE=mvp → 8개 핵심 도구만 로드
+ *
+ * Lazy Import (v1.2.0):
+ * - Profile 기반으로 필요한 모듈만 dynamic import
+ * - BitNet 도구가 비활성화된 profile에서는 해당 모듈 로드 스킵
+ */
+import { LEGACY_ALIAS_MAPPING, getLegacyDescription } from "./legacy_alias.js";
+import { isToolEnabled, getCurrentProfile, getProfileStats } from "./profile-config.js";
+/**
+ * Register tool only if enabled by current profile
+ * @returns true if tool was registered, false if skipped
+ */
+function registerIfEnabled(server, name, desc, schemaArg, handler) {
+    if (!isToolEnabled(name)) {
+        return false;
+    }
+    server.tool(name, desc, schemaArg, handler);
+    return true;
+}
+/**
+ * Check if any BitNet tool is enabled in current profile
+ */
+function isBitNetEnabled() {
+    return (isToolEnabled("bitnet.check") ||
+        isToolEnabled("bitnet.trace") ||
+        isToolEnabled("bitnet.signal"));
+}
+export async function registerAllTools(server) {
+    const profile = getCurrentProfile();
+    // Lazy import: always load vibe_pm (core tools)
+    const { defineVibePmTools, VIBE_PM_TOOL_DESCRIPTIONS } = await import("./tools/vibe_pm/index.js");
+    const pm = defineVibePmTools();
+    // Lazy import: load BitNet only if any bitnet tool is enabled
+    let bitnet = null;
+    let BITNET_TOOL_DESCRIPTIONS = {};
+    if (isBitNetEnabled()) {
+        const bitnetModule = await import("./tools/bitnet/index.js");
+        bitnet = bitnetModule.defineBitNetToolsV2();
+        BITNET_TOOL_DESCRIPTIONS = bitnetModule.BITNET_TOOL_DESCRIPTIONS;
+    }
+    let registeredCount = 0;
+    // ============================================================
+    // vibe_pm tools (filtered by profile)
+    // ============================================================
+    if (registerIfEnabled(server, "vibe_pm.status", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.status"], pm.statusInputSchema.shape, async (input) => pm.vibePmStatus(pm.statusInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.briefing", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.briefing"], pm.briefingInputSchema.shape, async (input) => pm.vibePmBriefing(pm.briefingInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.get_decision", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.get_decision"], pm.getDecisionInputSchema.shape, async (input) => pm.vibePmGetDecision(pm.getDecisionInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.submit_decision", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.submit_decision"], pm.submitDecisionInputSchema.shape, async (input) => pm.vibePmSubmitDecision(pm.submitDecisionInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.create_work_order", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.create_work_order"], pm.createWorkOrderInputSchema.shape, async (input) => pm.vibePmCreateWorkOrder(pm.createWorkOrderInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.inspect_code", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.inspect_code"], pm.inspectCodeInputSchema.shape, async (input) => pm.vibePmInspectCode(pm.inspectCodeInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.doctor", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.doctor"], pm.doctorInputSchema.shape, async (input) => pm.vibePmDoctor(pm.doctorInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.ingress", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ingress"], pm.ingressInputSchema.shape, async (input) => pm.vibePmIngress(pm.ingressInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.memory_status", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory_status"], pm.memoryStatusInputSchema.shape, async (input) => pm.vibePmMemoryStatus(pm.memoryStatusInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.memory_sync", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory_sync"], pm.memorySyncInputSchema.shape, async (input) => pm.vibePmMemorySync(pm.memorySyncInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.memory_retrieve", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory_retrieve"], pm.memoryRetrieveInputSchema.shape, async (input) => pm.vibePmMemoryRetrieve(pm.memoryRetrieveInputSchema.parse(input))))
+        registeredCount++;
+    // Consolidated memory tool (Tier 3 - preferred over individual memory_* tools)
+    if (registerIfEnabled(server, "vibe_pm.memory", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory"], pm.memoryInputSchema.shape, async (input) => pm.vibePmMemory(pm.memoryInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.init_docs", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.init_docs"], pm.initDocsInputSchema.shape, async (input) => pm.vibePmInitDocs(pm.initDocsInputSchema.parse(input))))
+        registeredCount++;
+    // XT Apps UI Tools (P2)
+    if (registerIfEnabled(server, "vibe_pm.ui_manifest", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ui_manifest"], pm.uiManifestInputSchema.shape, async (input) => pm.vibePmUIManifest(pm.uiManifestInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, "vibe_pm.ui_resource", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ui_resource"], pm.uiResourceInputSchema.shape, async (input) => pm.vibePmUIResource(pm.uiResourceInputSchema.parse(input))))
+        registeredCount++;
+    // Scaffold tool
+    if (registerIfEnabled(server, "vibe_pm.scaffold", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.scaffold"], pm.scaffoldInputSchema.shape, async (input) => pm.vibePmScaffold(pm.scaffoldInputSchema.parse(input))))
+        registeredCount++;
+    // Setup tool (one-click MCP configuration)
+    if (registerIfEnabled(server, "vibe_pm.setup", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.setup"], pm.setupInputSchema.shape, async (input) => pm.vibePmSetup(pm.setupInputSchema.parse(input))))
+        registeredCount++;
+    // ============================================================
+    // Legacy Alias (하위 호환) - always loaded for backwards compat
+    // ============================================================
+    const LEGACY_HANDLER_MAP = {
+        "vibe_pm.inspect_code": { schema: pm.inspectCodeInputSchema, handler: pm.vibePmInspectCode },
+        "vibe_pm.get_decision": { schema: pm.getDecisionInputSchema, handler: pm.vibePmGetDecision },
+        "vibe_pm.submit_decision": { schema: pm.submitDecisionInputSchema, handler: pm.vibePmSubmitDecision },
+        "vibe_pm.status": { schema: pm.statusInputSchema, handler: pm.vibePmStatus },
+        "vibe_pm.create_work_order": { schema: pm.createWorkOrderInputSchema, handler: pm.vibePmCreateWorkOrder },
+    };
+    let legacyCount = 0;
+    for (const [legacyName, newName] of Object.entries(LEGACY_ALIAS_MAPPING)) {
+        const target = LEGACY_HANDLER_MAP[newName];
+        if (target) {
+            server.tool(legacyName, getLegacyDescription(legacyName, newName), target.schema.shape, async (input) => target.handler(target.schema.parse(input)));
+            legacyCount++;
+        }
+    }
+    // ============================================================
+    // BitNet tools (lazy loaded, filtered by profile)
+    // ============================================================
+    let bitnetCount = 0;
+    // Only register BitNet tools if module was loaded
+    if (bitnet) {
+        if (registerIfEnabled(server, "bitnet.check", BITNET_TOOL_DESCRIPTIONS["bitnet.check"], bitnet.bitnetCheckInputSchema.shape, async (input) => bitnet.bitnetCheckHandler(bitnet.bitnetCheckInputSchema.parse(input))))
+            bitnetCount++;
+        if (registerIfEnabled(server, "bitnet.trace", BITNET_TOOL_DESCRIPTIONS["bitnet.trace"], bitnet.bitnetTraceInputSchema.shape, async (input) => bitnet.bitnetTraceHandler(bitnet.bitnetTraceInputSchema.parse(input))))
+            bitnetCount++;
+        if (registerIfEnabled(server, "bitnet.signal", BITNET_TOOL_DESCRIPTIONS["bitnet.signal"], bitnet.bitnetSignalInputSchema.shape, async (input) => bitnet.bitnetSignalHandler(bitnet.bitnetSignalInputSchema.parse(input))))
+            bitnetCount++;
+    }
+    // Log profile info
+    const stats = getProfileStats(profile);
+    console.error(`[vibe-pm] Profile: ${profile}, Tools: ${registeredCount} vibe_pm + ${legacyCount} legacy + ${bitnetCount} bitnet = ${registeredCount + legacyCount + bitnetCount} total`);
+}
+export async function captureRegistrySnapshot() {
+    const regs = [];
+    const spy = {
+        tool(name, desc, schemaArg, _handler) {
+            regs.push({ name, desc, schemaArg });
+        },
+    };
+    await registerAllTools(spy);
+    return regs;
+}