@vibecodetown/mcp-server 2.1.0

package/build/local-mode/bash.js

@@ -0,0 +1,61 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function findGitBashExe() {
+    const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+    const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+    const candidates = [
+        path.join(programFiles, "Git", "bin", "bash.exe"),
+        path.join(programFiles, "Git", "usr", "bin", "bash.exe"),
+        path.join(programFilesX86, "Git", "bin", "bash.exe"),
+        path.join(programFilesX86, "Git", "usr", "bin", "bash.exe")
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function canRunWsl() {
+    if (process.platform !== "win32")
+        return false;
+    const result = spawnSync("wsl", ["echo", "ok"], { encoding: "utf-8" });
+    return result.status === 0;
+}
+function toWslPath(winPath) {
+    const result = spawnSync("wsl", ["wslpath", "-a", winPath], { encoding: "utf-8" });
+    if (result.status !== 0) {
+        throw new Error(`wslpath failed for ${winPath}: ${result.stderr ?? ""}`);
+    }
+    return (result.stdout ?? "").trim();
+}
+function shSingleQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+export function hasBashRuntime() {
+    if (process.platform !== "win32") {
+        const bash = spawnSync("bash", ["--version"], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+        return bash.status === 0;
+    }
+    if (findGitBashExe())
+        return true;
+    return canRunWsl();
+}
+export function spawnBashScriptInRepoSync(repoRoot, scriptPath, scriptArgs, options) {
+    if (process.platform !== "win32") {
+        return spawnSync("bash", [scriptPath, ...scriptArgs], { ...options, cwd: repoRoot });
+    }
+    const gitBash = findGitBashExe();
+    if (gitBash) {
+        return spawnSync(gitBash, [scriptPath, ...scriptArgs], { ...options, cwd: repoRoot });
+    }
+    if (!canRunWsl())
+        return null;
+    const wslRepoRoot = toWslPath(repoRoot);
+    const wslScriptPath = toWslPath(scriptPath);
+    const cmd = [
+        `cd ${shSingleQuote(wslRepoRoot)}`,
+        `bash ${shSingleQuote(wslScriptPath)} ${scriptArgs.map(shSingleQuote).join(" ")}`
+    ].join(" && ");
+    return spawnSync("wsl", ["bash", "-lc", cmd], { ...options });
+}

package/build/local-mode/config.js

@@ -0,0 +1,171 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { VibeRepoConfigSchema } from "../generated/vibe_repo_config.js";
+export function isVibeRepo(repoRoot) {
+    return fs.existsSync(path.join(repoRoot, ".vibe"));
+}
+export function readRepoConfig(configFile) {
+    if (!fs.existsSync(configFile))
+        return null;
+    const raw = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+    // Backward compatibility: ignore legacy fields removed from SSOT.
+    if (raw && typeof raw === "object") {
+        delete raw.mcp;
+    }
+    return VibeRepoConfigSchema.parse(raw);
+}
+export function validateRepoConfig(configFile) {
+    try {
+        const config = readRepoConfig(configFile);
+        if (!config)
+            return { ok: false, error: `Missing config: ${configFile}` };
+        return { ok: true, config };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: message };
+    }
+}
+export function defaultRepoConfig(projectName, managedSinceIso) {
+    return VibeRepoConfigSchema.parse({
+        $schema: "https://vibecode.town/schemas/config.schema.json",
+        version: "1.0.3",
+        mode: "local-first",
+        project: {
+            name: projectName,
+            managed_since: managedSinceIso,
+        },
+        policy: {
+            no_ticket_no_work: true,
+            enforcement: "warn",
+            stale_hours: 24,
+            auto_update_on_start: "prompt",
+            safety_zones: {
+                green: ["src/**", "tests/**", "lib/**", "scripts/**"],
+                yellow: ["docs/**", "README.md", "*.md"],
+                red: ["config/**", ".env", ".env.*", "secrets/**", "credentials.*", "*.pem", "*.key"],
+                black: [".vibe/state/**", ".vibe/decisions/**", ".vibe/chroma/**", ".git/**"],
+            },
+        },
+        hooks: {
+            pre_commit: { enabled: false, enforcement: "warn" },
+            pre_push: { enabled: true, enforcement: "warn", gitleaks_required: false },
+        },
+        ai_agents: {
+            require_entrypoint_read: true,
+            require_briefing_before_work: true,
+        },
+    });
+}
+export function writeRepoConfig(configFile, config) {
+    fs.mkdirSync(path.dirname(configFile), { recursive: true });
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+export function setRepoConfigValue(configFile, key, value) {
+    const config = readRepoConfig(configFile);
+    if (!config)
+        return { ok: false, error: `Missing config: ${configFile}` };
+    try {
+        let updated = config;
+        switch (key) {
+            case "mode": {
+                if (value !== "local-first" && value !== "server-required") {
+                    return { ok: false, error: `Unsupported mode: ${value}` };
+                }
+                updated = { ...config, mode: value };
+                break;
+            }
+            case "policy.enforcement": {
+                if (value !== "warn" && value !== "block") {
+                    return { ok: false, error: `Unsupported policy.enforcement: ${value}` };
+                }
+                updated = {
+                    ...config,
+                    policy: {
+                        ...(config.policy ?? {}),
+                        enforcement: value,
+                    },
+                };
+                break;
+            }
+            case "policy.auto_update_on_start": {
+                if (value !== "off" && value !== "prompt" && value !== "silent") {
+                    return {
+                        ok: false,
+                        error: `Unsupported policy.auto_update_on_start: ${value} (use off|prompt|silent)`
+                    };
+                }
+                updated = {
+                    ...config,
+                    policy: {
+                        ...(config.policy ?? {}),
+                        auto_update_on_start: value,
+                    },
+                };
+                break;
+            }
+            case "hooks.pre_push.enabled": {
+                if (value !== "true" && value !== "false") {
+                    return { ok: false, error: `Unsupported hooks.pre_push.enabled: ${value} (use true|false)` };
+                }
+                const boolValue = value === "true";
+                updated = {
+                    ...config,
+                    hooks: {
+                        ...(config.hooks ?? {}),
+                        pre_push: {
+                            ...((config.hooks ?? {}).pre_push ?? {}),
+                            enabled: boolValue,
+                        },
+                    },
+                };
+                break;
+            }
+            case "hooks.pre_push.enforcement": {
+                if (value !== "warn" && value !== "block") {
+                    return { ok: false, error: `Unsupported hooks.pre_push.enforcement: ${value}` };
+                }
+                updated = {
+                    ...config,
+                    hooks: {
+                        ...(config.hooks ?? {}),
+                        pre_push: {
+                            ...((config.hooks ?? {}).pre_push ?? {}),
+                            enforcement: value,
+                        },
+                    },
+                };
+                break;
+            }
+            case "hooks.pre_push.gitleaks_required": {
+                if (value !== "true" && value !== "false") {
+                    return {
+                        ok: false,
+                        error: `Unsupported hooks.pre_push.gitleaks_required: ${value} (use true|false)`
+                    };
+                }
+                const boolValue = value === "true";
+                updated = {
+                    ...config,
+                    hooks: {
+                        ...(config.hooks ?? {}),
+                        pre_push: {
+                            ...((config.hooks ?? {}).pre_push ?? {}),
+                            gitleaks_required: boolValue,
+                        },
+                    },
+                };
+                break;
+            }
+            default:
+                return { ok: false, error: `Unsupported key: ${key}` };
+        }
+        const parsed = VibeRepoConfigSchema.parse(updated);
+        writeRepoConfig(configFile, parsed);
+        return { ok: true, config: parsed };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: message };
+    }
+}

package/build/local-mode/git.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+export function getGitRoot(cwd) {
+    const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.status !== 0)
+        return null;
+    const out = (result.stdout ?? "").trim();
+    return out.length > 0 ? out : null;
+}
+export function getGitHooksPath(cwd) {
+    const result = spawnSync("git", ["config", "--local", "--get", "core.hooksPath"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.status !== 0)
+        return null;
+    const out = (result.stdout ?? "").trim();
+    return out.length > 0 ? out : null;
+}
+export function setGitHooksPath(cwd, hooksPath) {
+    const result = spawnSync("git", ["config", "--local", "core.hooksPath", hooksPath], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.status === 0)
+        return { ok: true };
+    return { ok: false, error: (result.stderr ?? "git config failed").trim() };
+}

package/build/local-mode/init.js

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { defaultRepoConfig, isVibeRepo, writeRepoConfig } from "./config.js";
+import { hasBashRuntime } from "./bash.js";
+import { setGitHooksPath } from "./git.js";
+import { getVibeRepoPaths } from "./paths.js";
+import { GITHUB_ACTIONS_LOCAL_MODE_GUARD_WORKFLOW_TEMPLATE, GITLEAKS_CONFIG_TEMPLATE, PRE_PUSH_HOOK_TEMPLATE, VALIDATE_SH_TEMPLATE } from "./templates.js";
+function ensureGitignoreLine(gitignorePath, line) {
+    const normalizedLine = line.endsWith("\n") ? line : `${line}\n`;
+    if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, normalizedLine, "utf-8");
+        return;
+    }
+    const current = fs.readFileSync(gitignorePath, "utf-8");
+    const lines = new Set(current.split(/\r?\n/));
+    const candidate = line.replace(/\r?\n$/, "");
+    if (lines.has(candidate))
+        return;
+    const suffix = current.endsWith("\n") ? "" : "\n";
+    fs.writeFileSync(gitignorePath, `${current}${suffix}${line}\n`, "utf-8");
+}
+function chmodExecutable(filePath) {
+    try {
+        fs.chmodSync(filePath, 0o755);
+    }
+    catch {
+        // Best-effort (Windows)
+    }
+}
+export function initLocalModeRepo(repoRoot, opts) {
+    const paths = getVibeRepoPaths(repoRoot);
+    const created = [];
+    const updated = [];
+    const notes = [];
+    const force = opts?.force ?? false;
+    const installHooks = opts?.installHooks ?? true;
+    const installCi = opts?.installCi ?? false;
+    const ciFailOnWarn = opts?.ciFailOnWarn ?? false;
+    fs.mkdirSync(paths.stateDir, { recursive: true });
+    fs.mkdirSync(paths.hooksDir, { recursive: true });
+    fs.mkdirSync(paths.libDir, { recursive: true });
+    fs.mkdirSync(paths.archiveDir, { recursive: true });
+    fs.mkdirSync(path.dirname(paths.gitleaksConfigFile), { recursive: true });
+    const nowIso = new Date().toISOString();
+    const projectName = path.basename(repoRoot);
+    if (!fs.existsSync(paths.configFile) || force) {
+        const config = defaultRepoConfig(projectName, nowIso);
+        writeRepoConfig(paths.configFile, config);
+        (force ? updated : created).push(paths.configFile);
+    }
+    if (!fs.existsSync(paths.validateScript) || force) {
+        fs.writeFileSync(paths.validateScript, VALIDATE_SH_TEMPLATE, "utf-8");
+        chmodExecutable(paths.validateScript);
+        (force ? updated : created).push(paths.validateScript);
+    }
+    if (!fs.existsSync(paths.gitleaksConfigFile) || force) {
+        fs.writeFileSync(paths.gitleaksConfigFile, GITLEAKS_CONFIG_TEMPLATE, "utf-8");
+        (force ? updated : created).push(paths.gitleaksConfigFile);
+    }
+    if (!fs.existsSync(paths.prePushHook) || force) {
+        fs.writeFileSync(paths.prePushHook, PRE_PUSH_HOOK_TEMPLATE, "utf-8");
+        chmodExecutable(paths.prePushHook);
+        (force ? updated : created).push(paths.prePushHook);
+    }
+    if (installCi) {
+        const workflowDir = path.dirname(paths.ciWorkflowFile);
+        fs.mkdirSync(workflowDir, { recursive: true });
+        if (!fs.existsSync(paths.ciWorkflowFile) || force) {
+            const workflow = ciFailOnWarn
+                ? GITHUB_ACTIONS_LOCAL_MODE_GUARD_WORKFLOW_TEMPLATE.replace('VIBE_FAIL_ON_WARN: "false"', 'VIBE_FAIL_ON_WARN: "true"')
+                : GITHUB_ACTIONS_LOCAL_MODE_GUARD_WORKFLOW_TEMPLATE;
+            fs.writeFileSync(paths.ciWorkflowFile, workflow, "utf-8");
+            (force ? updated : created).push(paths.ciWorkflowFile);
+        }
+    }
+    ensureGitignoreLine(path.join(repoRoot, ".gitignore"), ".vibe/state/");
+    if (installHooks) {
+        const set = setGitHooksPath(repoRoot, ".vibe/hooks");
+        if (set.ok) {
+            notes.push("git core.hooksPath = .vibe/hooks");
+        }
+        else {
+            notes.push(`git core.hooksPath setup skipped: ${set.error}`);
+        }
+    }
+    if (installCi) {
+        notes.push(`GitHub Actions workflow: ${path.relative(repoRoot, paths.ciWorkflowFile)}`);
+    }
+    if (!isVibeRepo(repoRoot)) {
+        // should never happen given we created it; but keep safe.
+        notes.push(".vibe directory missing after init (unexpected).");
+    }
+    // Best-effort sanity check: ensure bash exists for hooks/validate.
+    if (!hasBashRuntime()) {
+        notes.push("bash not found: local guard scripts may not run (install Git Bash or WSL).");
+    }
+    // P0-3: Bootstrap manifest 생성 (self-block 방지)
+    const allManaged = [...created, ...updated].map(p => path.relative(repoRoot, p).replace(/\\/g, "/"));
+    const manifest = {
+        schema_version: 1,
+        created_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + 3600_000).toISOString(), // 1시간
+        consumed: false,
+        reason: "SYSTEM_BOOTSTRAP",
+        managed_paths: allManaged,
+    };
+    fs.writeFileSync(paths.bootstrapManifest, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+    created.push(paths.bootstrapManifest);
+    return { created, updated, notes };
+}

package/build/local-mode/paths.js

@@ -0,0 +1,24 @@
+import * as path from "node:path";
+export function getVibeRepoPaths(repoRoot) {
+    const vibeDir = path.join(repoRoot, ".vibe");
+    const stateDir = path.join(vibeDir, "state");
+    const hooksDir = path.join(vibeDir, "hooks");
+    const libDir = path.join(vibeDir, "lib");
+    const ciWorkflowFile = path.join(repoRoot, ".github", "workflows", "vibe-local-mode-guard.yml");
+    const gitleaksConfigFile = path.join(repoRoot, "config", "gitleaks", ".gitleaks.toml");
+    return {
+        repoRoot,
+        vibeDir,
+        configFile: path.join(vibeDir, "config.json"),
+        stateDir,
+        currentWorkOrderFile: path.join(stateDir, "current_work_order.json"),
+        archiveDir: path.join(vibeDir, "archive"),
+        hooksDir,
+        libDir,
+        validateScript: path.join(libDir, "validate.sh"),
+        prePushHook: path.join(hooksDir, "pre-push"),
+        ciWorkflowFile,
+        gitleaksConfigFile,
+        bootstrapManifest: path.join(vibeDir, "bootstrap_manifest.json"),
+    };
+}