@vibecodetown/mcp-server 2.2.4 → 2.2.6

package/build/bootstrap/installer.js

@@ -437,6 +437,239 @@ export async function checkUpdates() {
     }
     return result;
 }
+/**
+ * Parse engine version from asset filename
+ * Format: {prefix}_{version}_{platform}.tar.gz
+ * Example: spec-high_1.0.0_linux_x64.tar.gz
+ */
+function parseEngineVersionFromAsset(assetName) {
+    const match = assetName.match(/^(.+?)_(\d+\.\d+\.\d+)_(.+)\.tar\.gz$/);
+    if (!match)
+        return null;
+    return {
+        prefix: match[1],
+        version: match[2],
+        platform: match[3],
+    };
+}
+/**
+ * Find the latest engines release from GitHub
+ */
+async function discoverLatestEnginesRelease(repo) {
+    if (isOfflineMode())
+        return null;
+    const apiBase = `https://api.github.com/repos/${repo}/releases`;
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
+        // Get all releases and find latest engines-v* tag
+        const res = await fetch(`${apiBase}?per_page=20`, {
+            signal: controller.signal,
+            headers: {
+                ...getAuthHeaders(),
+                "Accept": "application/vnd.github+json",
+            },
+        });
+        clearTimeout(timeoutId);
+        if (!res.ok)
+            return null;
+        const releases = await res.json();
+        // Find latest engines release
+        const enginesRelease = releases.find(r => r.tag_name.startsWith("engines-v"));
+        if (enginesRelease) {
+            if (isDebugMode()) {
+                console.log(`[debug] Found latest engines release: ${enginesRelease.tag_name}`);
+            }
+            return enginesRelease;
+        }
+        return null;
+    }
+    catch (e) {
+        if (isDebugMode()) {
+            console.log(`[debug] Failed to discover latest release: ${e}`);
+        }
+        return null;
+    }
+}
+/**
+ * Extract engine versions from release assets
+ */
+function extractEngineVersionsFromRelease(release, platform) {
+    const versions = new Map();
+    for (const asset of release.assets) {
+        const parsed = parseEngineVersionFromAsset(asset.name);
+        if (!parsed || parsed.platform !== platform)
+            continue;
+        // Map asset prefix to engine name
+        const engineName = Object.keys(ENGINE_SPECS).find(name => ENGINE_SPECS[name].assetPrefix === parsed.prefix);
+        if (engineName) {
+            versions.set(engineName, {
+                name: engineName,
+                version: parsed.version,
+                assetName: asset.name,
+            });
+        }
+    }
+    return versions;
+}
+/**
+ * Check for remote updates from GitHub Releases
+ * This allows updates without npm package update
+ */
+export async function checkRemoteUpdates() {
+    const platform = detectPlatform();
+    const result = {
+        available: false,
+        engines: [],
+        releaseTag: null,
+    };
+    // Use first engine's repo (all engines use same repo)
+    const repo = ENGINE_SPECS["spec-high"].repo;
+    const release = await discoverLatestEnginesRelease(repo);
+    if (!release) {
+        return result;
+    }
+    result.releaseTag = release.tag_name;
+    const remoteVersions = extractEngineVersionsFromRelease(release, platform);
+    for (const name of Object.keys(ENGINE_SPECS)) {
+        const currentVersion = await getCurrentVersion(name);
+        const remote = remoteVersions.get(name);
+        if (remote) {
+            const needsUpdate = currentVersion !== remote.version;
+            result.engines.push({
+                name,
+                currentVersion,
+                remoteVersion: remote.version,
+                needsUpdate,
+            });
+            if (needsUpdate) {
+                result.available = true;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Update engines from remote release (ignoring registry.ts versions)
+ */
+export async function updateFromRemote(force = false) {
+    const platform = detectPlatform();
+    const repo = ENGINE_SPECS["spec-high"].repo;
+    const release = await discoverLatestEnginesRelease(repo);
+    const updated = [];
+    const failed = [];
+    if (!release) {
+        if (isDebugMode()) {
+            console.log("[debug] No remote release found");
+        }
+        return { updated, failed };
+    }
+    const remoteVersions = extractEngineVersionsFromRelease(release, platform);
+    for (const name of Object.keys(ENGINE_SPECS)) {
+        const remote = remoteVersions.get(name);
+        if (!remote)
+            continue;
+        const currentVersion = await getCurrentVersion(name);
+        const needsUpdate = force || currentVersion !== remote.version;
+        if (!needsUpdate)
+            continue;
+        try {
+            // Download and install from remote
+            await installEngineFromRelease(name, release, remote.version, platform);
+            updated.push(name);
+            if (isDebugMode()) {
+                console.log(`[debug] Updated ${name}: ${currentVersion} → ${remote.version}`);
+            }
+        }
+        catch (e) {
+            failed.push(name);
+            if (isDebugMode()) {
+                console.log(`[debug] Failed to update ${name}: ${e}`);
+            }
+        }
+    }
+    return { updated, failed };
+}
+/**
+ * Install a specific engine from a GitHub release
+ */
+async function installEngineFromRelease(name, release, version, platform) {
+    const spec = ENGINE_SPECS[name];
+    const asset = `${spec.assetPrefix}_${version}_${platform}.tar.gz`;
+    const dir = engineDir(name, version, platform);
+    const bin = path.join(dir, exeName(spec.assetPrefix));
+    const marker = path.join(dir, ".installed");
+    const archivePath = path.join(dir, asset);
+    const assetInfo = findAsset(release, asset);
+    const shaInfo = findAsset(release, spec.shaSumsAsset);
+    if (!assetInfo) {
+        throw new Error(`Asset not found: ${asset}`);
+    }
+    // Read SHA256
+    let shaMap;
+    if (shaInfo) {
+        const token = getGitHubToken();
+        if (token) {
+            const res = await fetchWithRetry(shaInfo.url, MAX_RETRIES, {
+                "Accept": "application/octet-stream",
+            });
+            const text = await res.text();
+            shaMap = new Map();
+            for (const line of text.split("\n")) {
+                const t = line.trim();
+                if (!t)
+                    continue;
+                const m = t.match(/^([a-fA-F0-9]{64})\s+(.+)$/);
+                if (m)
+                    shaMap.set(m[2].trim(), m[1].toLowerCase());
+            }
+        }
+        else {
+            shaMap = await readShaSumsFromUrl(shaInfo.browser_download_url);
+        }
+    }
+    else {
+        throw new Error(`SHA256SUMS not found in release`);
+    }
+    const expected = shaMap.get(asset);
+    if (!expected)
+        throw new Error(`sha_missing_for_asset:${asset}`);
+    // Clean and prepare directory
+    await fs.promises.rm(dir, { recursive: true, force: true }).catch(() => { });
+    await fs.promises.mkdir(dir, { recursive: true });
+    // Download
+    if (getGitHubToken()) {
+        await downloadAsset(assetInfo, archivePath);
+    }
+    else {
+        await download(assetInfo.browser_download_url, archivePath);
+    }
+    // Verify SHA256
+    const got = (await sha256File(archivePath)).toLowerCase();
+    if (got !== expected)
+        throw new Error(`sha_mismatch:${asset}`);
+    // Extract
+    await extractTarGz(archivePath, dir);
+    // Find binary
+    const candidates = [
+        path.join(dir, exeName(spec.assetPrefix)),
+        path.join(dir, spec.assetPrefix, exeName(spec.assetPrefix))
+    ];
+    const found = await firstExisting(candidates);
+    if (!found)
+        throw new Error(`bin_not_found_after_extract:${spec.assetPrefix}`);
+    // Normalize location
+    if (found !== bin) {
+        await fs.promises.copyFile(found, bin);
+    }
+    await makeExecutable(bin);
+    await fs.promises.writeFile(marker, `ok ${new Date().toISOString()}\n`, "utf-8");
+    // Update version tracker
+    await setCurrentVersion(name, version);
+    // Clean up
+    await fs.promises.rm(archivePath, { force: true }).catch(() => { });
+    return bin;
+}
 // ============================================================
 // Cache Validation
 // ============================================================

package/build/generated/contracts_bundle_info.js

@@ -1,5 +1,5 @@
 // Auto-generated from schemas/contracts.version.json + schemas/contracts.lock.json
 // DO NOT EDIT MANUALLY - run scripts/generate-contracts.sh
-export const CONTRACTS_VERSION = "1.8.6";
-export const CONTRACTS_BUNDLE_SHA256 = "117ae96448d5d0bd988281ae7170facabc90c20da074d1d3e845c63cc734ba06";
+export const CONTRACTS_VERSION = "1.8.7";
+export const CONTRACTS_BUNDLE_SHA256 = "a1e258a6eda62a87093b91e7bc28e2cde414450a05c26f3ba52b0e6eaa0660e1";
 export const CONTRACTS_SCHEMA_COUNT = 103;

package/build/generated/doctor_output.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export const DoctorOutputSchema = z.object({ "status": z.enum(["OK", "FIXED", "NEEDS_ATTENTION", "ERROR"]), "summary": z.string().min(1), "contracts": z.object({ "version": z.string().min(1), "bundle_sha256": z.string().min(1), "schema_count": z.number().int().gte(0) }).strict().optional(), "engines": z.array(z.object({ "name": z.string().min(1), "status": z.enum(["정상", "업데이트 필요", "설치 필요", "손상됨"]), "version": z.string().min(1), "current_version": z.union([z.string(), z.null()]) }).strict()), "actions_taken": z.array(z.string()).optional(), "local_memory": z.any().superRefine((x, ctx) => {
+export const DoctorOutputSchema = z.object({ "status": z.enum(["OK", "FIXED", "NEEDS_ATTENTION", "ERROR"]), "summary": z.string().min(1), "contracts": z.object({ "version": z.string().min(1), "bundle_sha256": z.string().min(1), "schema_count": z.number().int().gte(0) }).strict().optional(), "engines": z.array(z.object({ "name": z.string().min(1), "status": z.enum(["정상", "업데이트 필요", "설치 필요", "손상됨"]), "version": z.string().min(1), "current_version": z.union([z.string(), z.null()]) }).strict()), "actions_taken": z.array(z.string()).optional(), "python_cli": z.object({ "status": z.enum(["정상", "오류"]), "message": z.string().min(1), "pythonpath_detected": z.union([z.string(), z.null()]) }).strict().optional(), "skills": z.object({ "status": z.enum(["OK", "WARN", "ERROR"]), "version": z.union([z.string(), z.null()]), "installed": z.number().int().gte(0), "total": z.number().int().gte(0) }).strict().optional(), "remote_updates": z.object({ "available": z.boolean(), "release_tag": z.union([z.string(), z.null()]), "updates": z.array(z.object({ "name": z.string().min(1), "current": z.union([z.string(), z.null()]), "remote": z.string().min(1) }).strict()) }).strict().optional(), "local_memory": z.any().superRefine((x, ctx) => {
         const schemas = [z.object({ "project_id": z.string().min(1), "status": z.enum(["READY", "NEEDS_SYNC", "OFFLINE_NO_INDEX", "ERROR"]), "summary": z.string().min(1), "docs_root": z.string().min(1), "persist_dir": z.string().min(1), "collection": z.string().min(1), "stats": z.object({ "document_count": z.number().int().gte(0), "chunk_count": z.number().int().gte(0), "last_sync_at": z.union([z.string(), z.null()]).optional() }).strict(), "embedding": z.object({ "backend": z.string().min(1), "model": z.union([z.string(), z.null()]).optional(), "ready": z.boolean() }).strict().optional(), "offline_mode": z.boolean(), "issues": z.array(z.string()), "next_action": z.any().superRefine((x, ctx) => {
                     const schemas = [z.object({ "tool": z.enum(["vibe_pm.memory_sync", "vibe_pm.doctor"]), "reason": z.string().min(1) }).strict(), z.null()];
                     const errors = schemas.reduce((errors, schema) => ((result) => result.error ? [...errors, result.error] : errors)(schema.safeParse(x)), []);

package/build/generated/update_input.js

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export const UpdateInputSchema = z.object({ "force": z.boolean().describe("캐시를 무시하고 강제로 재설치할지 여부 (기본: false)").default(false), "engines": z.array(z.string().min(1)).describe("업데이트할 엔진 목록 (미지정 시 전체)").optional() }).strict().describe("SSOT schema for vibe_pm.update MCP tool input");
+export const UpdateInputSchema = z.object({ "target": z.enum(["engines", "npm", "local", "all"]).describe("업데이트 대상: engines(엔진 바이너리), npm(npm 패키지), local(로컬 git pull + build), all(전체)").default("engines"), "force": z.boolean().describe("캐시를 무시하고 강제로 재설치할지 여부 (기본: false)").default(false), "engines": z.array(z.string().min(1)).describe("업데이트할 엔진 목록 (미지정 시 전체, target=engines일 때만 적용)").optional(), "local_path": z.string().min(1).describe("로컬 개발 폴더 경로 (target=local/all일 때 사용, 미지정 시 VIBE_LOCAL_DEV_PATH 환경변수 사용)").optional() }).strict().describe("SSOT schema for vibe_pm.update MCP tool input");

package/build/generated/update_output.js

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export const UpdateOutputSchema = z.object({ "status": z.enum(["OK", "PARTIAL", "ERROR"]), "summary": z.string().min(1), "results": z.array(z.object({ "name": z.string().min(1), "action": z.enum(["updated", "skipped", "failed"]), "from_version": z.union([z.string(), z.null()]), "to_version": z.string().min(1), "message": z.string().min(1) }).strict()), "next_action": z.object({ "type": z.enum(["NONE", "RETRY", "CONTACT_SUPPORT"]), "message": z.string().min(1) }).strict() }).strict().describe("SSOT schema for vibe_pm.update MCP tool output");
+export const UpdateOutputSchema = z.object({ "status": z.enum(["OK", "PARTIAL", "ERROR"]), "summary": z.string().min(1), "results": z.array(z.object({ "name": z.string().min(1), "action": z.enum(["updated", "skipped", "failed"]), "from_version": z.union([z.string(), z.null()]), "to_version": z.string().min(1), "message": z.string().min(1) }).strict()).describe("엔진 업데이트 결과 목록 (target=engines/all일 때)").optional(), "npm_result": z.object({ "action": z.enum(["updated", "skipped", "failed"]), "from_version": z.union([z.string(), z.null()]).optional(), "to_version": z.union([z.string(), z.null()]).optional(), "message": z.string().min(1) }).strict().describe("npm 패키지 업데이트 결과 (target=npm/all일 때)").optional(), "local_result": z.object({ "action": z.enum(["updated", "skipped", "failed"]), "path": z.string().min(1).optional(), "git_status": z.string().optional(), "build_status": z.string().optional(), "message": z.string().min(1) }).strict().describe("로컬 빌드 업데이트 결과 (target=local/all일 때)").optional(), "next_action": z.object({ "type": z.enum(["NONE", "RETRY", "RESTART_CLAUDE", "CONTACT_SUPPORT"]), "message": z.string().min(1) }).strict() }).strict().describe("SSOT schema for vibe_pm.update MCP tool output");

package/build/local-mode/version-lock.js

@@ -1,10 +1,12 @@
 // adapters/mcp-ts/src/local-mode/version-lock.ts
 // Version lock management for unified installation
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { z } from "zod";
 import { getVibeRepoPaths } from "./paths.js";
 export const VersionLockSchema = z.object({
     schema_version: z.literal(1),
+    repo_root: z.string().min(1).optional(),
     created_at: z.string(),
     updated_at: z.string(),
     cli: z.object({
@@ -18,6 +20,7 @@ export const VersionLockSchema = z.object({
 });
 /**
  * Read version lock file from repo
+ * Auto-injects repo_root if missing (migration for existing files)
  */
 export function readVersionLock(repoRoot) {
     const paths = getVibeRepoPaths(repoRoot);
@@ -25,6 +28,10 @@ export function readVersionLock(repoRoot) {
         return null;
     try {
         const data = JSON.parse(fs.readFileSync(paths.versionLockFile, "utf-8"));
+        // Auto-inject repo_root if missing (migration for existing lock files)
+        if (!data.repo_root) {
+            data.repo_root = path.resolve(repoRoot);
+        }
         return VersionLockSchema.parse(data);
     }
     catch {
@@ -38,8 +45,11 @@ export function writeVersionLock(repoRoot, cliVersion, engines) {
     const paths = getVibeRepoPaths(repoRoot);
     const now = new Date().toISOString();
     const existing = readVersionLock(repoRoot);
+    // Store absolute path for later reference (e.g., vibe_pm.update with target=local)
+    const absoluteRepoRoot = path.resolve(repoRoot);
     const lock = {
         schema_version: 1,
+        repo_root: absoluteRepoRoot,
         created_at: existing?.created_at ?? now,
         updated_at: now,
         cli: { name: "@vibecode/mcp-server", version: cliVersion },

package/build/tools/vibe_pm/update.js

@@ -1,30 +1,193 @@
 // adapters/mcp-ts/src/tools/vibe_pm/update.ts
-// vibe_pm.update - Manual engine update
+// vibe_pm.update - Unified update tool (engines + npm + local build)
 import { UpdateInputSchema } from "../../generated/update_input.js";
-import { ensureEngines, checkUpdates, clearCache, getEngineHealth } from "../../bootstrap/installer.js";
+import { ensureEngines, checkUpdates, clearCache, getEngineHealth, checkRemoteUpdates, updateFromRemote } from "../../bootstrap/installer.js";
 import { ENGINE_SPECS } from "../../bootstrap/registry.js";
+import { invokeCli } from "../../runtime/cli_invoker.js";
+import { readVersionLock } from "../../local-mode/version-lock.js";
 // ============================================================
 // Input/Output Types
 // ============================================================
 export { UpdateInputSchema };
 // ============================================================
-// Update Implementation
+// Helper Functions
 // ============================================================
 /**
- * vibe_pm.update - Manual engine update
- *
- * PM-friendly description:
- * 엔진 바이너리를 최신 버전으로 업데이트합니다.
+ * Update npm package (@vibecodetown/mcp-server)
  */
-export async function update(input) {
-    const force = input.force ?? false;
-    const targetEngines = input.engines ?? Object.keys(ENGINE_SPECS);
+async function updateNpmPackage() {
+    const cwd = process.cwd();
+    try {
+        // Get current version
+        let fromVersion = null;
+        try {
+            const listResult = await invokeCli({
+                bin: "npm",
+                args: ["list", "@vibecodetown/mcp-server", "--json"],
+                cwd,
+                timeoutMs: 30000
+            });
+            if (listResult.exitCode === 0) {
+                const parsed = JSON.parse(listResult.stdout);
+                fromVersion = parsed.dependencies?.["@vibecodetown/mcp-server"]?.version ?? null;
+            }
+        }
+        catch {
+            // Not installed globally, might be using npx
+        }
+        // Clear npx cache and update
+        await invokeCli({
+            bin: "npm",
+            args: ["cache", "clean", "--force"],
+            cwd,
+            timeoutMs: 30000
+        });
+        // Try to update global package
+        try {
+            await invokeCli({
+                bin: "npm",
+                args: ["update", "-g", "@vibecodetown/mcp-server"],
+                cwd,
+                timeoutMs: 60000
+            });
+        }
+        catch {
+            // Global update failed, try clearing npx cache
+        }
+        // Get new version
+        let toVersion = null;
+        try {
+            const showResult = await invokeCli({
+                bin: "npm",
+                args: ["show", "@vibecodetown/mcp-server", "version"],
+                cwd,
+                timeoutMs: 30000
+            });
+            if (showResult.exitCode === 0) {
+                toVersion = showResult.stdout.trim();
+            }
+        }
+        catch {
+            // Could not fetch remote version
+        }
+        if (toVersion && fromVersion !== toVersion) {
+            return {
+                action: "updated",
+                from_version: fromVersion,
+                to_version: toVersion,
+                message: "npm 패키지 업데이트 완료 (npx 캐시 클리어됨)"
+            };
+        }
+        else if (toVersion) {
+            return {
+                action: "skipped",
+                from_version: fromVersion,
+                to_version: toVersion,
+                message: "이미 최신 버전입니다"
+            };
+        }
+        else {
+            return {
+                action: "failed",
+                from_version: fromVersion,
+                to_version: null,
+                message: "버전 확인 실패"
+            };
+        }
+    }
+    catch (e) {
+        return {
+            action: "failed",
+            from_version: null,
+            to_version: null,
+            message: e instanceof Error ? e.message : "npm 업데이트 실패"
+        };
+    }
+}
+/**
+ * Update local development build (git pull + npm run build)
+ */
+async function updateLocalBuild(localPath) {
+    const result = {
+        action: "updated",
+        path: localPath,
+        git_status: "",
+        build_status: "",
+        message: ""
+    };
+    try {
+        // Step 1: git pull
+        const gitResult = await invokeCli({
+            bin: "git",
+            args: ["pull", "origin", "main"],
+            cwd: localPath,
+            timeoutMs: 60000
+        });
+        if (gitResult.exitCode !== 0) {
+            result.git_status = "failed";
+            result.action = "failed";
+            result.message = `git pull 실패: ${gitResult.stderr || gitResult.stdout}`;
+            return result;
+        }
+        result.git_status = gitResult.stdout.includes("Already up to date")
+            ? "already_up_to_date"
+            : "pulled";
+        // Step 2: npm run build (in adapters/mcp-ts)
+        const mcpTsPath = `${localPath}/adapters/mcp-ts`;
+        const buildResult = await invokeCli({
+            bin: "npm",
+            args: ["run", "build"],
+            cwd: mcpTsPath,
+            timeoutMs: 60000
+        });
+        if (buildResult.exitCode !== 0) {
+            result.build_status = "failed";
+            result.action = "failed";
+            result.message = `빌드 실패: ${buildResult.stderr || buildResult.stdout}`;
+            return result;
+        }
+        result.build_status = "success";
+        // Success
+        if (result.git_status === "already_up_to_date") {
+            result.action = "skipped";
+            result.message = "이미 최신 상태입니다 (빌드 갱신됨)";
+        }
+        else {
+            result.action = "updated";
+            result.message = "git pull + 빌드 완료";
+        }
+        return result;
+    }
+    catch (e) {
+        return {
+            action: "failed",
+            path: localPath,
+            git_status: "error",
+            build_status: "error",
+            message: e instanceof Error ? e.message : "로컬 업데이트 실패"
+        };
+    }
+}
+/**
+ * Update engines (existing logic extracted)
+ */
+async function updateEngines(targetEngines, force) {
     const results = [];
     try {
-        // Step 1: Check what needs updating
+        // Check for remote updates first (GitHub Releases)
+        const remoteUpdates = await checkRemoteUpdates();
+        const hasRemoteUpdates = remoteUpdates.available;
+        // Check local registry updates
         const updateStatus = await checkUpdates();
-        // Step 2: Filter engines to update
+        // Determine what to update (prefer remote versions)
         const enginesToUpdate = [];
+        const remoteVersionMap = new Map();
+        // Build remote version map
+        for (const engine of remoteUpdates.engines) {
+            if (engine.needsUpdate) {
+                remoteVersionMap.set(engine.name, engine.remoteVersion);
+            }
+        }
         for (const name of targetEngines) {
             if (!(name in ENGINE_SPECS)) {
                 results.push({
@@ -38,7 +201,9 @@ export async function update(input) {
             }
             const engineName = name;
             const status = updateStatus[engineName];
-            if (force || status.needsUpdate) {
+            const remoteVersion = remoteVersionMap.get(engineName);
+            // Update if: force mode, local needs update, OR remote has newer version
+            if (force || status.needsUpdate || remoteVersion) {
                 enginesToUpdate.push(engineName);
             }
             else {
@@ -51,84 +216,230 @@ export async function update(input) {
                 });
             }
         }
-        // Step 3: Clear cache if force mode
+        // Clear cache if force mode
         if (force) {
             for (const name of enginesToUpdate) {
                 await clearCache(name);
             }
         }
-        // Step 4: Update engines
+        // Update engines
         if (enginesToUpdate.length > 0) {
-            // Run ensureEngines which will update anything that needs updating
-            await ensureEngines();
-            // Check results
-            const newHealth = await getEngineHealth();
-            for (const name of enginesToUpdate) {
-                const health = newHealth.find((h) => h.name === name);
-                const oldStatus = updateStatus[name];
-                if (health?.status === "ok") {
-                    results.push({
-                        name,
-                        action: "updated",
-                        from_version: oldStatus.current,
-                        to_version: health.version,
-                        message: force ? "강제 재설치 완료" : "업데이트 완료"
-                    });
+            if (hasRemoteUpdates) {
+                const remoteResult = await updateFromRemote(force);
+                const newHealth = await getEngineHealth();
+                for (const name of enginesToUpdate) {
+                    const health = newHealth.find((h) => h.name === name);
+                    const oldStatus = updateStatus[name];
+                    const remoteVersion = remoteVersionMap.get(name);
+                    if (remoteResult.updated.includes(name)) {
+                        results.push({
+                            name,
+                            action: "updated",
+                            from_version: oldStatus.current,
+                            to_version: remoteVersion ?? health?.version ?? oldStatus.required,
+                            message: force ? "강제 재설치 완료 (원격)" : "업데이트 완료 (원격)"
+                        });
+                    }
+                    else if (remoteResult.failed.includes(name)) {
+                        results.push({
+                            name,
+                            action: "failed",
+                            from_version: oldStatus.current,
+                            to_version: remoteVersion ?? oldStatus.required,
+                            message: "원격 업데이트 실패"
+                        });
+                    }
+                    else if (health?.status === "ok") {
+                        results.push({
+                            name,
+                            action: "skipped",
+                            from_version: oldStatus.current,
+                            to_version: health.version,
+                            message: "이미 최신 버전입니다"
+                        });
+                    }
+                }
+            }
+            else {
+                // Fallback to local registry update
+                await ensureEngines();
+                const newHealth = await getEngineHealth();
+                for (const name of enginesToUpdate) {
+                    const health = newHealth.find((h) => h.name === name);
+                    const oldStatus = updateStatus[name];
+                    if (health?.status === "ok") {
+                        results.push({
+                            name,
+                            action: "updated",
+                            from_version: oldStatus.current,
+                            to_version: health.version,
+                            message: force ? "강제 재설치 완료" : "업데이트 완료"
+                        });
+                    }
+                    else {
+                        results.push({
+                            name,
+                            action: "failed",
+                            from_version: oldStatus.current,
+                            to_version: oldStatus.required,
+                            message: `업데이트 실패: ${health?.status ?? "unknown"}`
+                        });
+                    }
                 }
-                else {
-                    results.push({
-                        name,
-                        action: "failed",
-                        from_version: oldStatus.current,
-                        to_version: oldStatus.required,
-                        message: `업데이트 실패: ${health?.status ?? "unknown"}`
-                    });
+            }
+        }
+        return results;
+    }
+    catch (e) {
+        results.push({
+            name: "engines",
+            action: "failed",
+            from_version: null,
+            to_version: "unknown",
+            message: e instanceof Error ? e.message : "엔진 업데이트 실패"
+        });
+        return results;
+    }
+}
+// ============================================================
+// Main Update Function
+// ============================================================
+/**
+ * vibe_pm.update - Unified update tool
+ *
+ * PM-friendly description:
+ * 엔진, npm 패키지, 로컬 빌드를 업데이트합니다.
+ *
+ * target options:
+ * - "engines": 엔진 바이너리만 업데이트 (기본값)
+ * - "npm": npm 패키지만 업데이트
+ * - "local": 로컬 개발 환경만 업데이트 (git pull + build)
+ * - "all": 전체 업데이트
+ */
+export async function update(input) {
+    const target = input.target ?? "engines";
+    const force = input.force ?? false;
+    const targetEngines = input.engines ?? Object.keys(ENGINE_SPECS);
+    // Resolve local path: input > env > version_lock.json
+    let localPath = input.local_path ?? process.env.VIBE_LOCAL_DEV_PATH;
+    if (!localPath && (target === "local" || target === "all")) {
+        const versionLock = readVersionLock(process.cwd());
+        if (versionLock?.repo_root) {
+            localPath = versionLock.repo_root;
+        }
+    }
+    let engineResults;
+    let npmResult;
+    let localResult;
+    let needsRestart = false;
+    try {
+        // Execute updates based on target
+        if (target === "engines" || target === "all") {
+            engineResults = await updateEngines(targetEngines, force);
+        }
+        if (target === "npm" || target === "all") {
+            npmResult = await updateNpmPackage();
+            if (npmResult.action === "updated") {
+                needsRestart = true;
+            }
+        }
+        if (target === "local" || target === "all") {
+            if (!localPath) {
+                localResult = {
+                    action: "failed",
+                    path: "(not configured)",
+                    git_status: "error",
+                    build_status: "error",
+                    message: "로컬 경로가 지정되지 않았습니다. 'vibe setup'을 먼저 실행하거나, local_path 파라미터를 지정하세요."
+                };
+            }
+            else {
+                localResult = await updateLocalBuild(localPath);
+                if (localResult.action === "updated") {
+                    needsRestart = true;
                 }
             }
         }
-        // Step 5: Generate summary
-        const updated = results.filter((r) => r.action === "updated").length;
-        const skipped = results.filter((r) => r.action === "skipped").length;
-        const failed = results.filter((r) => r.action === "failed").length;
+        // Generate summary
+        const summaryParts = [];
+        let hasError = false;
+        let hasUpdate = false;
+        if (engineResults) {
+            const engineUpdated = engineResults.filter((r) => r.action === "updated").length;
+            const engineFailed = engineResults.filter((r) => r.action === "failed").length;
+            if (engineUpdated > 0) {
+                summaryParts.push(`엔진 ${engineUpdated}개 업데이트`);
+                hasUpdate = true;
+            }
+            if (engineFailed > 0) {
+                summaryParts.push(`엔진 ${engineFailed}개 실패`);
+                hasError = true;
+            }
+        }
+        if (npmResult) {
+            if (npmResult.action === "updated") {
+                summaryParts.push("npm 패키지 업데이트");
+                hasUpdate = true;
+            }
+            else if (npmResult.action === "failed") {
+                summaryParts.push("npm 업데이트 실패");
+                hasError = true;
+            }
+        }
+        if (localResult) {
+            if (localResult.action === "updated") {
+                summaryParts.push("로컬 빌드 업데이트");
+                hasUpdate = true;
+            }
+            else if (localResult.action === "failed") {
+                summaryParts.push("로컬 빌드 실패");
+                hasError = true;
+            }
+        }
+        // Determine status and next action
         let status;
-        let summary;
         let nextAction;
-        if (failed > 0 && updated === 0) {
+        if (hasError && !hasUpdate) {
             status = "ERROR";
-            summary = `업데이트 실패: ${failed}개 엔진`;
             nextAction = {
                 type: "RETRY",
-                message: "force: true 옵션으로 다시 시도하거나, 네트워크 연결을 확인하세요."
+                message: "업데이트에 실패했습니다. force: true 옵션으로 다시 시도하세요."
             };
         }
-        else if (failed > 0) {
+        else if (hasError) {
             status = "PARTIAL";
-            summary = `부분 성공: ${updated}개 업데이트, ${failed}개 실패`;
             nextAction = {
-                type: "RETRY",
-                message: "실패한 엔진은 force: true 옵션으로 다시 시도하세요."
+                type: needsRestart ? "RESTART_CLAUDE" : "RETRY",
+                message: needsRestart
+                    ? "일부 업데이트 완료. Claude Code를 재시작하세요."
+                    : "일부 업데이트 실패. 실패 항목을 확인하세요."
             };
         }
-        else if (updated > 0) {
+        else if (hasUpdate) {
             status = "OK";
-            summary = `${updated}개 엔진 업데이트 완료`;
             nextAction = {
-                type: "NONE",
-                message: "모든 엔진이 최신 버전입니다."
+                type: needsRestart ? "RESTART_CLAUDE" : "NONE",
+                message: needsRestart
+                    ? "업데이트 완료. Claude Code를 재시작하면 적용됩니다."
+                    : "업데이트 완료."
             };
         }
         else {
             status = "OK";
-            summary = "모든 엔진이 이미 최신 버전입니다";
             nextAction = {
                 type: "NONE",
-                message: "업데이트할 항목이 없습니다."
+                message: "모두 최신 상태입니다."
             };
         }
+        const summary = summaryParts.length > 0
+            ? summaryParts.join(", ")
+            : "업데이트할 항목이 없습니다";
         return {
             status,
             summary,
-            results,
+            results: engineResults,
+            npm_result: npmResult,
+            local_result: localResult,
             next_action: nextAction
         };
     }
@@ -136,10 +447,12 @@ export async function update(input) {
         return {
             status: "ERROR",
             summary: e instanceof Error ? e.message : "알 수 없는 오류",
-            results,
+            results: engineResults,
+            npm_result: npmResult,
+            local_result: localResult,
             next_action: {
                 type: "CONTACT_SUPPORT",
-                message: "업데이트 중 오류가 발생했습니다. 네트워크 연결을 확인하고 다시 시도하세요."
+                message: "업데이트 중 오류가 발생했습니다."
             }
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibecodetown/mcp-server",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "type": "module",
   "description": "Vibe PM - AI Project Manager MCP Server for non-technical founders",
   "keywords": [