@vibecodetown/mcp-server 2.1.4 → 2.2.0

package/build/tools/vibe_pm/publish_mcp.js

@@ -0,0 +1,271 @@
+// adapters/mcp-ts/src/tools/vibe_pm/publish_mcp.ts
+// MCP build and publish workflow
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { getCredentialStore } from "../../auth/credential_store.js";
+/**
+ * Check if MCP source files have changed since last build
+ */
+async function hasSourceChanges(mcpRoot) {
+    const srcDir = path.join(mcpRoot, "src");
+    const buildDir = path.join(mcpRoot, "build");
+    // If no build folder, definitely changed
+    if (!fs.existsSync(buildDir)) {
+        return { changed: true, files: ["build/ not found"] };
+    }
+    // Get build timestamp
+    const buildIndex = path.join(buildDir, "index.js");
+    if (!fs.existsSync(buildIndex)) {
+        return { changed: true, files: ["build/index.js not found"] };
+    }
+    const buildStat = fs.statSync(buildIndex);
+    const buildTime = buildStat.mtime.getTime();
+    // Find source files newer than build
+    const changedFiles = [];
+    function checkDir(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                checkDir(fullPath);
+            }
+            else if (entry.name.endsWith(".ts")) {
+                const stat = fs.statSync(fullPath);
+                if (stat.mtime.getTime() > buildTime) {
+                    changedFiles.push(path.relative(mcpRoot, fullPath));
+                }
+            }
+        }
+    }
+    checkDir(srcDir);
+    return { changed: changedFiles.length > 0, files: changedFiles };
+}
+/**
+ * Run TypeScript build
+ */
+function runBuild(mcpRoot) {
+    try {
+        const result = spawnSync("npm", ["run", "build"], {
+            cwd: mcpRoot,
+            encoding: "utf-8",
+            shell: true,
+            timeout: 120_000, // 2 minutes
+        });
+        if (result.status === 0) {
+            return { success: true, output: result.stdout || "" };
+        }
+        return { success: false, output: result.stderr || result.stdout || "Build failed" };
+    }
+    catch (e) {
+        return { success: false, output: e instanceof Error ? e.message : String(e) };
+    }
+}
+/**
+ * Bump version in package.json
+ */
+function bumpVersion(mcpRoot, type) {
+    try {
+        const result = spawnSync("npm", ["version", type, "--no-git-tag-version"], {
+            cwd: mcpRoot,
+            encoding: "utf-8",
+            shell: true,
+        });
+        if (result.status === 0) {
+            // Read new version from package.json
+            const pkgPath = path.join(mcpRoot, "package.json");
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            return pkg.version;
+        }
+        throw new Error(result.stderr || "Version bump failed");
+    }
+    catch (e) {
+        throw new Error(`Version bump failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Run npm publish
+ */
+async function runPublish(mcpRoot, dryRun) {
+    const store = getCredentialStore();
+    const npmToken = await store.getNpmToken();
+    // Set NPM_TOKEN if we have one stored
+    const env = { ...process.env };
+    if (npmToken) {
+        env.NPM_TOKEN = npmToken;
+    }
+    try {
+        const args = ["publish", "--access", "public"];
+        if (dryRun) {
+            args.push("--dry-run");
+        }
+        const result = spawnSync("npm", args, {
+            cwd: mcpRoot,
+            encoding: "utf-8",
+            shell: true,
+            env,
+            timeout: 120_000, // 2 minutes
+        });
+        if (result.status === 0) {
+            return { success: true, output: result.stdout || "" };
+        }
+        return { success: false, output: result.stderr || result.stdout || "Publish failed" };
+    }
+    catch (e) {
+        return { success: false, output: e instanceof Error ? e.message : String(e) };
+    }
+}
+/**
+ * vibe_pm.publish_mcp - Build and publish MCP package
+ *
+ * Workflow:
+ * 1. Check for source changes (skip if no changes unless --force)
+ * 2. Run npm build (tsc)
+ * 3. Optionally bump version
+ * 4. Run npm publish
+ *
+ * PM-friendly description:
+ * MCP 패키지를 빌드하고 npm에 배포합니다.
+ */
+export async function publishMcp(input, basePath = process.cwd()) {
+    const warnings = [];
+    // Find MCP root (adapters/mcp-ts)
+    const mcpRoot = path.join(basePath, "adapters", "mcp-ts");
+    if (!fs.existsSync(path.join(mcpRoot, "package.json"))) {
+        return {
+            success: false,
+            phase: "check",
+            version: "unknown",
+            built: false,
+            published: false,
+            message: "MCP 패키지를 찾을 수 없습니다: adapters/mcp-ts/package.json",
+            warnings,
+        };
+    }
+    // Read current version
+    const pkgPath = path.join(mcpRoot, "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    let version = pkg.version;
+    // Phase 1: Check for changes
+    const { changed, files } = await hasSourceChanges(mcpRoot);
+    if (!changed && !input.force && !input.skip_build) {
+        return {
+            success: true,
+            phase: "check",
+            version,
+            built: false,
+            published: false,
+            message: "소스 변경 없음. 빌드 스킵.",
+            warnings: ["--force로 강제 빌드 가능"],
+        };
+    }
+    // Phase 2: Build
+    let built = false;
+    if (!input.skip_build) {
+        const buildResult = runBuild(mcpRoot);
+        if (!buildResult.success) {
+            return {
+                success: false,
+                phase: "build",
+                version,
+                built: false,
+                published: false,
+                message: `빌드 실패: ${buildResult.output}`,
+                warnings,
+            };
+        }
+        built = true;
+        if (files.length > 0) {
+            warnings.push(`변경된 파일: ${files.slice(0, 5).join(", ")}${files.length > 5 ? ` 외 ${files.length - 5}개` : ""}`);
+        }
+    }
+    // Build only mode
+    if (input.build_only) {
+        return {
+            success: true,
+            phase: "build",
+            version,
+            built,
+            published: false,
+            message: `빌드 완료 (v${version})`,
+            warnings,
+            next_action: {
+                tool: "vibe_pm.publish_mcp",
+                reason: "배포하려면 build_only: false로 다시 실행",
+            },
+        };
+    }
+    // Phase 3: Version bump (optional)
+    if (input.bump) {
+        try {
+            version = bumpVersion(mcpRoot, input.bump);
+            warnings.push(`버전 범프: ${pkg.version} → ${version}`);
+        }
+        catch (e) {
+            return {
+                success: false,
+                phase: "publish",
+                version,
+                built,
+                published: false,
+                message: e instanceof Error ? e.message : String(e),
+                warnings,
+            };
+        }
+    }
+    // Phase 4: Publish
+    const publishResult = await runPublish(mcpRoot, input.dry_run ?? false);
+    if (!publishResult.success) {
+        // Check if it's an auth error
+        if (publishResult.output.includes("ENEEDAUTH") || publishResult.output.includes("401")) {
+            return {
+                success: false,
+                phase: "publish",
+                version,
+                built,
+                published: false,
+                message: "npm 인증 실패. NPM_TOKEN을 설정하거나 npm login을 실행하세요.",
+                warnings: [
+                    "vibe config set npm_token <TOKEN> 으로 토큰 저장 가능",
+                    "또는 NPM_TOKEN 환경변수 설정",
+                ],
+            };
+        }
+        return {
+            success: false,
+            phase: "publish",
+            version,
+            built,
+            published: false,
+            message: `배포 실패: ${publishResult.output}`,
+            warnings,
+        };
+    }
+    const dryRunMsg = input.dry_run ? " (dry-run)" : "";
+    return {
+        success: true,
+        phase: "complete",
+        version,
+        built,
+        published: !input.dry_run,
+        message: `@vibecodetown/mcp-server@${version} 배포 완료${dryRunMsg}`,
+        warnings,
+        next_action: {
+            tool: "vibe_pm.status",
+            reason: "배포 상태 확인",
+        },
+    };
+}
+/**
+ * Quick check if MCP needs rebuild
+ */
+export async function needsMcpBuild(basePath = process.cwd()) {
+    const mcpRoot = path.join(basePath, "adapters", "mcp-ts");
+    if (!fs.existsSync(path.join(mcpRoot, "package.json"))) {
+        return false;
+    }
+    const { changed } = await hasSourceChanges(mcpRoot);
+    return changed;
+}

package/build/tools/vibe_pm/run_app.js

@@ -1,9 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/run_app.ts
 // vibe_pm.run_app - One-click application launch
+//
+// All subprocess invocations go through cli_invoker for centralized management.
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
+import { invokeSystem, invokeSystemSync, spawnDetached } from "../../runtime/cli_invoker.js";
 import { resolveRunDir, resolveRunId } from "./context.js";
 import { buildPodmanRunCommand, filterContainerEnvAllowlist, normalizeMounts, normalizePorts } from "./run_app_podman.js";
 /**
@@ -49,19 +51,10 @@ export async function runApp(input) {
     // Step 2: Start process
     const fullCommand = `${projectInfo.command} ${projectInfo.args.join(" ")}`.trim();
     try {
-        const child = spawn(projectInfo.command, projectInfo.args, {
-            cwd: basePath,
-            detached: true,
-            stdio: "ignore",
-            env: {
-                ...process.env,
-                PORT: String(projectInfo.port),
-                NODE_ENV: mode === "prod" ? "production" : "development"
-            }
+        const pid = spawnDetached(projectInfo.command, projectInfo.args, basePath, {
+            PORT: String(projectInfo.port),
+            NODE_ENV: mode === "prod" ? "production" : "development"
         });
-        // Unref to allow parent to exit independently
-        child.unref();
-        const pid = child.pid;
         // Give the process a moment to start
         await new Promise((resolve) => setTimeout(resolve, 500));
         writeRunAppEvidenceBestEffort(basePath, {
@@ -70,11 +63,11 @@ export async function runApp(input) {
             port: projectInfo.port,
             url: projectInfo.url,
             command_executed: fullCommand,
-            process_id: pid
+            process_id: pid ?? undefined
         });
         return {
             success: true,
-            process_id: pid,
+            process_id: pid ?? undefined,
             url: projectInfo.url,
             command_executed: fullCommand,
             message: `애플리케이션이 시작되었습니다. ${projectInfo.url} 에서 확인하세요.`,
@@ -160,10 +153,31 @@ function normalizeOpaPaths(basePath, values) {
     }
     return out;
 }
+/**
+ * P1-3: Extract script name from package manager commands
+ * npm run dev -> "dev", npm start -> "start", etc.
+ */
+function extractScriptName(command, args) {
+    const packageManagers = ["npm", "yarn", "pnpm", "bun"];
+    if (!packageManagers.includes(command))
+        return undefined;
+    // npm run <script>, yarn run <script>, pnpm run <script>, bun run <script>
+    const runIdx = args.indexOf("run");
+    if (runIdx >= 0 && args[runIdx + 1]) {
+        return args[runIdx + 1];
+    }
+    // npm start, npm test, etc. (shortcuts)
+    const shortcuts = ["start", "test", "build"];
+    if (args.length > 0 && shortcuts.includes(args[0])) {
+        return args[0];
+    }
+    return undefined;
+}
 function buildOpaPolicyInput(basePath, command, args, opts) {
     const cwd = normalizeOpaPath(basePath);
     const paths = normalizeOpaPaths(basePath, opts?.paths ?? [basePath]);
     const mounts = opts?.mounts ? normalizeOpaPaths(basePath, opts.mounts) : undefined;
+    const scriptName = extractScriptName(command, args);
     return {
         action: "run_app",
         project_root: cwd,
@@ -172,7 +186,8 @@ function buildOpaPolicyInput(basePath, command, args, opts) {
             args,
             cwd,
             paths,
-            mounts
+            mounts,
+            script_name: scriptName
         },
         meta: {
             tool: "vibe_pm.run_app",
@@ -198,14 +213,14 @@ function evaluateOpaGate(basePath, input) {
             writeJsonBestEffort(resultPath, deny);
         return deny;
     }
-    const opa = spawnSync("opa", ["eval", "-f", "json", "-I", "-d", policyPath, "data.vibepm.runapp"], { input: JSON.stringify(input), encoding: "utf-8", timeout: 1500 });
-    if (opa.error) {
-        const err = opa.error;
-        const missing = err?.code === "ENOENT";
+    const opa = invokeSystemSync("opa", ["eval", "-f", "json", "-I", "-d", policyPath, "data.vibepm.runapp"], basePath, { input: JSON.stringify(input), timeoutMs: 1500 });
+    // Check for spawn errors (binary not found, etc.)
+    if (opa.exitCode === 127 || opa.stderr.includes("[SPAWN_ERROR]")) {
+        const missing = opa.stderr.includes("ENOENT") || opa.stderr.includes("not found");
         const deny = {
             allow: false,
             reasons: [
-                missing ? "OPA_POLICY_MISSING: opa binary not found" : `OPA_POLICY_EVAL_FAILED: ${err.message ?? "unknown error"}`
+                missing ? "OPA_POLICY_MISSING: opa binary not found" : `OPA_POLICY_EVAL_FAILED: ${opa.stderr}`
             ],
             matched_rules: [missing ? "OPA_POLICY_MISSING" : "OPA_POLICY_EVAL_FAILED"]
         };
@@ -213,10 +228,10 @@ function evaluateOpaGate(basePath, input) {
             writeJsonBestEffort(resultPath, deny);
         return deny;
     }
-    if (opa.status !== 0) {
+    if (opa.exitCode !== 0) {
         const deny = {
             allow: false,
-            reasons: [`OPA_POLICY_EVAL_FAILED: exit_code=${opa.status}`],
+            reasons: [`OPA_POLICY_EVAL_FAILED: exit_code=${opa.exitCode}`],
             matched_rules: ["OPA_POLICY_EVAL_FAILED"]
         };
         if (resultPath)
@@ -282,19 +297,10 @@ function writeRunAppEvidenceBestEffort(repoRootAbs, payload) {
     }
 }
 async function assertPodmanAvailable() {
-    await new Promise((resolve, reject) => {
-        const p = spawn("podman", ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
-        let out = "";
-        let err = "";
-        p.stdout.on("data", (d) => (out += String(d)));
-        p.stderr.on("data", (d) => (err += String(d)));
-        p.on("error", reject);
-        p.on("close", (code) => {
-            if (code === 0)
-                return resolve();
-            reject(new Error(`podman_unavailable: code=${code} out=${out} err=${err}`));
-        });
-    });
+    const result = await invokeSystem("podman", ["--version"], process.cwd());
+    if (result.exitCode !== 0) {
+        throw new Error(`podman_unavailable: code=${result.exitCode} out=${result.stdout} err=${result.stderr}`);
+    }
 }
 function defaultImageForProject(projectType) {
     if (projectType === "node")
@@ -328,15 +334,12 @@ function buildInsideCommand(projectInfo) {
     return run;
 }
 async function runPodmanDetached(cmd) {
-    return await new Promise((resolve, reject) => {
-        const p = spawn(cmd.cmd, cmd.args, { stdio: ["ignore", "pipe", "pipe"] });
-        let out = "";
-        let err = "";
-        p.stdout.on("data", (d) => (out += String(d)));
-        p.stderr.on("data", (d) => (err += String(d)));
-        p.on("error", reject);
-        p.on("close", (code) => resolve({ exitCode: code ?? 1, stdout: out, stderr: err }));
-    });
+    const result = await invokeSystem(cmd.cmd, cmd.args, process.cwd());
+    return {
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr
+    };
 }
 async function runAppWithPodman(input, repoRootAbs, mode, projectInfo) {
     const image = input.container_image ?? defaultImageForProject(projectInfo.type);

package/build/tools/vibe_pm/save_rule.js

@@ -0,0 +1,120 @@
+// adapters/mcp-ts/src/tools/vibe_pm/save_rule.ts
+// vibe_pm.save_rule - 프로젝트 워크플로우 규칙 저장
+import { z } from "zod";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { getVibeRepoPaths } from "../../local-mode/paths.js";
+// ============================================================
+// Schema
+// ============================================================
+export const saveRuleInputSchema = z.object({
+    base_path: z.string().describe("프로젝트 루트 경로"),
+    rule_title: z.string().min(1).describe("규칙 제목 (예: 'API 변경 시 문서 갱신')"),
+    trigger: z.string().min(1).describe("언제 적용되는지 (예: 'API 엔드포인트를 수정할 때마다')"),
+    action: z.string().min(1).describe("무엇을 해야 하는지 (예: 'docs/api.md를 함께 갱신한다')"),
+    example: z.string().optional().describe("구체적인 예시 (선택)")
+}).strict();
+export const saveRuleOutputSchema = z.object({
+    status: z.enum(["saved", "error"]),
+    message: z.string(),
+    rules_file: z.string().describe(".vibe/project_rules.md 경로"),
+    rule_count: z.number().describe("현재 저장된 규칙 수")
+}).strict();
+// ============================================================
+// Implementation
+// ============================================================
+const RULES_FILENAME = "project_rules.md";
+/**
+ * 규칙 파일 경로 반환
+ */
+function getRulesFilePath(basePath) {
+    const { vibeDir } = getVibeRepoPaths(basePath);
+    return path.join(vibeDir, RULES_FILENAME);
+}
+/**
+ * 규칙 파일 읽기 (없으면 기본 템플릿 반환)
+ */
+async function readRulesFile(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf-8");
+    }
+    catch {
+        // 파일이 없으면 기본 템플릿 반환
+        return `# Project Workflow Rules
+
+> 이 파일은 Vibe PM이 자동으로 관리합니다.
+> 프로젝트별 워크플로우 규칙이 여기에 저장됩니다.
+
+---
+
+`;
+    }
+}
+/**
+ * 규칙 수 계산
+ */
+function countRules(content) {
+    const lines = content.split("\n");
+    let count = 0;
+    for (const line of lines) {
+        if (line.startsWith("## ") && !line.includes("Project Workflow Rules")) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * 새 규칙을 마크다운 형식으로 포맷
+ */
+function formatRule(input) {
+    const timestamp = new Date().toISOString().split("T")[0];
+    let rule = `## ${input.rule_title}
+
+- **언제**: ${input.trigger}
+- **무엇을**: ${input.action}
+`;
+    if (input.example) {
+        rule += `- **예시**: ${input.example}
+`;
+    }
+    rule += `- **등록일**: ${timestamp}
+
+---
+
+`;
+    return rule;
+}
+/**
+ * 규칙 저장
+ */
+export async function saveRule(input) {
+    const rulesFile = getRulesFilePath(input.base_path);
+    try {
+        // .vibe 디렉토리 확인/생성
+        const vibeDir = path.dirname(rulesFile);
+        await fs.mkdir(vibeDir, { recursive: true });
+        // 기존 규칙 읽기
+        let content = await readRulesFile(rulesFile);
+        // 새 규칙 추가
+        const newRule = formatRule(input);
+        content += newRule;
+        // 파일 저장
+        await fs.writeFile(rulesFile, content, "utf-8");
+        const ruleCount = countRules(content);
+        return {
+            status: "saved",
+            message: `규칙 '${input.rule_title}'이(가) 저장되었습니다.`,
+            rules_file: rulesFile,
+            rule_count: ruleCount
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            status: "error",
+            message: `규칙 저장 실패: ${msg}`,
+            rules_file: rulesFile,
+            rule_count: 0
+        };
+    }
+}

package/build/tools/vibe_pm/undo_last_task.js

@@ -1,10 +1,10 @@
 // adapters/mcp-ts/src/tools/vibe_pm/undo_last_task.ts
 // vibe_pm.undo_last_task - Time machine rollback via git revert
+//
+// All subprocess invocations go through cli_invoker for centralized management.
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-const execAsync = promisify(exec);
+import { invokeGit } from "../../runtime/cli_invoker.js";
 /**
  * vibe_pm.undo_last_task - Rollback recent commits via git revert
  *
@@ -43,25 +43,20 @@ export async function undoLastTask(input) {
     const revertedTasks = [];
     const revertErrors = [];
     for (const commit of commits) {
-        try {
-            await execAsync(`git revert --no-edit ${commit.hash}`, { cwd: basePath });
+        const result = await invokeGit(["revert", "--no-edit", commit.hash], basePath);
+        if (result.exitCode === 0) {
             revertedTasks.push({
                 commit_hash: commit.shortHash,
                 task_summary: commit.subject,
                 timestamp: commit.timestamp
             });
         }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
+        else {
+            const errMsg = result.stderr || result.stdout;
             revertErrors.push(`${commit.shortHash}: ${errMsg}`);
             // If revert fails due to conflicts, abort and stop
             if (errMsg.includes("conflict") || errMsg.includes("CONFLICT")) {
-                try {
-                    await execAsync("git revert --abort", { cwd: basePath });
-                }
-                catch {
-                    // Ignore abort errors
-                }
+                await invokeGit(["revert", "--abort"], basePath);
                 break;
             }
         }
@@ -99,9 +94,12 @@ export async function undoLastTask(input) {
  * Get recent commits from git log
  */
 async function getRecentCommits(basePath, count) {
-    const { stdout } = await execAsync(`git log --oneline -n ${count} --format="%H|%h|%s|%ci"`, { cwd: basePath });
+    const result = await invokeGit(["log", "--oneline", "-n", String(count), "--format=%H|%h|%s|%ci"], basePath);
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr || "git log failed");
+    }
     const commits = [];
-    const lines = stdout.trim().split("\n").filter(Boolean);
+    const lines = result.stdout.trim().split("\n").filter(Boolean);
     for (const line of lines) {
         const [hash, shortHash, subject, timestamp] = line.split("|");
         if (hash && shortHash && subject) {
@@ -119,13 +117,11 @@ async function getRecentCommits(basePath, count) {
  * Get current HEAD commit hash
  */
 async function getCurrentCommit(basePath) {
-    try {
-        const { stdout } = await execAsync("git rev-parse --short HEAD", { cwd: basePath });
-        return stdout.trim();
-    }
-    catch {
+    const result = await invokeGit(["rev-parse", "--short", "HEAD"], basePath);
+    if (result.exitCode !== 0) {
         return "unknown";
     }
+    return result.stdout.trim();
 }
 /**
  * Add rollback entry to DEV_LOG

package/build/version-check.js

@@ -3,14 +3,14 @@
 // 정책: 절대 실행을 막지 않는다 (모든 실패는 GO)
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import readline from "node:readline";
+import { invokeGitSync } from "./runtime/cli_invoker.js";
 function execGit(args, cwd) {
-    const r = spawnSync("git", args, { cwd, encoding: "utf-8", timeout: 10000 });
+    const result = invokeGitSync(args, cwd, { timeoutMs: 10000 });
     return {
-        status: r.status,
-        stdout: r.stdout ?? "",
-        stderr: r.stderr ?? "",
+        status: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
     };
 }
 function repoRootOrNull(cwd) {