@vibecodetown/mcp-server 2.1.4 → 2.2.1

package/build/tools/vibe_pm/python_error.js

@@ -0,0 +1,115 @@
+// adapters/mcp-ts/src/tools/vibe_pm/python_error.ts
+// Shared Python CLI error classification
+/**
+ * Classify Python CLI error for better diagnostics
+ *
+ * @param stderr - Standard error output from Python CLI
+ * @param code - Exit code
+ * @param context - Optional context (e.g., "Local Memory", "Advisory Review")
+ * @returns Classified error with actionable next steps
+ */
+export function classifyPythonError(stderr, code, context) {
+    const lowerStderr = stderr.toLowerCase();
+    const ctx = context ?? "작업";
+    // ModuleNotFoundError: vibecoding_helper not found
+    if (lowerStderr.includes("modulenotfounderror") || lowerStderr.includes("no module named")) {
+        return {
+            issueCode: "python_module_not_found",
+            summary: "Python 패키지를 찾을 수 없습니다. PYTHONPATH 또는 패키지 설치를 확인하세요.",
+            nextAction: { tool: "vibe_pm.doctor", reason: "Python 환경을 점검하겠습니다." }
+        };
+    }
+    // Rust binary error (wrong routing - should not happen after fix)
+    if (lowerStderr.includes("unrecognized subcommand") || lowerStderr.includes("usage: vibecoding-helper")) {
+        return {
+            issueCode: "wrong_binary_routing",
+            summary: "Python CLI 대신 Rust 바이너리가 호출되었습니다. MCP 서버 버전을 확인하세요.",
+            nextAction: { tool: "vibe_pm.update", reason: "MCP 서버를 최신 버전으로 업데이트하겠습니다." }
+        };
+    }
+    // Python not found
+    if (lowerStderr.includes("python") && (lowerStderr.includes("not found") || lowerStderr.includes("command not found"))) {
+        return {
+            issueCode: "python_not_found",
+            summary: "Python이 설치되어 있지 않거나 PATH에 없습니다.",
+            nextAction: { tool: "vibe_pm.doctor", reason: "Python 설치 상태를 점검하겠습니다." }
+        };
+    }
+    // ChromaDB / embedding error
+    if (lowerStderr.includes("chromadb") || lowerStderr.includes("embedding")) {
+        return {
+            issueCode: "chromadb_error",
+            summary: "Local Memory 인덱스(ChromaDB) 오류가 발생했습니다.",
+            nextAction: { tool: "vibe_pm.memory_sync", reason: "인덱스를 재생성하겠습니다." }
+        };
+    }
+    // Permission error
+    if (lowerStderr.includes("permission denied") || lowerStderr.includes("access denied")) {
+        return {
+            issueCode: "permission_denied",
+            summary: "파일 접근 권한 오류입니다.",
+            nextAction: { tool: "vibe_pm.doctor", reason: "파일 권한을 점검하겠습니다." }
+        };
+    }
+    // Disk space / write error
+    if (lowerStderr.includes("no space left") || lowerStderr.includes("disk full")) {
+        return {
+            issueCode: "disk_full",
+            summary: "디스크 공간이 부족합니다.",
+            nextAction: { tool: "vibe_pm.doctor", reason: "디스크 상태를 점검하겠습니다." }
+        };
+    }
+    // Timeout
+    if (lowerStderr.includes("[timeout]")) {
+        return {
+            issueCode: "timeout",
+            summary: `${ctx} 실행이 시간 초과되었습니다.`,
+            nextAction: { tool: "vibe_pm.doctor", reason: "시스템 상태를 점검하겠습니다." }
+        };
+    }
+    // Import error (other than module not found)
+    if (lowerStderr.includes("importerror")) {
+        return {
+            issueCode: "import_error",
+            summary: "Python 모듈 import 중 오류가 발생했습니다. 의존성을 확인하세요.",
+            nextAction: { tool: "vibe_pm.doctor", reason: "Python 환경을 점검하겠습니다." }
+        };
+    }
+    // Syntax error
+    if (lowerStderr.includes("syntaxerror")) {
+        return {
+            issueCode: "syntax_error",
+            summary: "Python 코드에 문법 오류가 있습니다. 패키지 버전을 확인하세요.",
+            nextAction: { tool: "vibe_pm.update", reason: "패키지를 최신 버전으로 업데이트하겠습니다." }
+        };
+    }
+    // JSON decode error
+    if (lowerStderr.includes("jsondecodeerror") || lowerStderr.includes("json.decoder")) {
+        return {
+            issueCode: "json_decode_error",
+            summary: "JSON 파싱 오류가 발생했습니다. 입력 데이터를 확인하세요.",
+            nextAction: { tool: "vibe_pm.status", reason: "현재 상태를 확인하겠습니다." }
+        };
+    }
+    // Network error
+    if (lowerStderr.includes("connectionerror") || lowerStderr.includes("urlerror") || lowerStderr.includes("timeout") && lowerStderr.includes("connect")) {
+        return {
+            issueCode: "network_error",
+            summary: "네트워크 연결 오류가 발생했습니다.",
+            nextAction: { tool: "vibe_pm.doctor", reason: "네트워크 상태를 점검하겠습니다." }
+        };
+    }
+    // Default: unknown error
+    return {
+        issueCode: `engine_exit_code_${code}`,
+        summary: `${ctx}에 실패했습니다.`,
+        nextAction: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+    };
+}
+/**
+ * Format error issue string
+ */
+export function formatErrorIssue(classified, stderr, code) {
+    const detail = stderr?.trim() || `exit_code=${code}`;
+    return `${classified.issueCode}: ${detail}`;
+}

package/build/tools/vibe_pm/run_app.js

@@ -1,11 +1,16 @@
 // 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 { resolveRunDir, resolveRunId } from "./context.js";
+import { decode as decodeMsgpack } from "@msgpack/msgpack";
+import { invokeSystem, invokeSystemSync, spawnDetached } from "../../runtime/cli_invoker.js";
+import { getRunContext, resolveRunDir, resolveRunId } from "./context.js";
 import { buildPodmanRunCommand, filterContainerEnvAllowlist, normalizeMounts, normalizePorts } from "./run_app_podman.js";
+import { isOpaEvalFailedError, isOpaMissingError } from "../../errors.js";
+import { toPosixPath, resolveRelativePosix, normalizePathArray } from "../../path-utils.js";
 /**
  * vibe_pm.run_app - Auto-detect project type and run
  *
@@ -15,21 +20,28 @@ import { buildPodmanRunCommand, filterContainerEnvAllowlist, normalizeMounts, no
  * 3. Start process in background
  * 4. Return URL and PID
  */
-export async function runApp(input) {
-    const basePath = process.cwd();
+export async function runApp(input, basePath = process.cwd()) {
     const mode = input.mode ?? "dev";
     const customPort = input.port;
     const container = input.container ?? "none";
-    // Step 1: Detect project type and get run info
-    const projectInfo = detectProject(basePath, mode, customPort);
-    if (projectInfo.type === "unknown") {
+    const runtime = container === "podman" ? "podman" : "host";
+    // Step 1: Resolve execution candidate from ingress entrypoints artifact (SSOT)
+    const runIdForArtifacts = resolveRunIdForSecurity(basePath);
+    const entrySel = selectEntrypointCandidate({
+        basePath,
+        run_id: runIdForArtifacts,
+        mode,
+        option_key: input?.option_key
+    });
+    if (!entrySel.ok) {
         return {
             success: false,
-            command_executed: "detect_project",
-            message: "프로젝트 유형을 감지할 수 없습니다. package.json 또는 requirements.txt가 필요합니다.",
-            runtime: "host"
+            command_executed: "select_entrypoint",
+            message: entrySel.message,
+            runtime
         };
     }
+    const projectInfo = projectInfoFromCandidate(entrySel.candidate, mode, customPort);
     if (container === "podman") {
         return await runAppWithPodman(input, basePath, mode, projectInfo);
     }
@@ -43,25 +55,16 @@ export async function runApp(input) {
             success: false,
             command_executed: `${projectInfo.command} ${projectInfo.args.join(" ")}`.trim(),
             message: formatOpaBlockMessage(opaDecision),
-            runtime: "host"
+            runtime
         };
     }
     // 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,15 +73,17 @@ export async function runApp(input) {
             port: projectInfo.port,
             url: projectInfo.url,
             command_executed: fullCommand,
-            process_id: pid
+            process_id: pid ?? undefined,
+            entrypoint_key: entrySel.candidate.key,
+            entrypoint_label: entrySel.candidate.label
         });
         return {
             success: true,
-            process_id: pid,
+            process_id: pid ?? undefined,
             url: projectInfo.url,
             command_executed: fullCommand,
             message: `애플리케이션이 시작되었습니다. ${projectInfo.url} 에서 확인하세요.`,
-            runtime: "host"
+            runtime
         };
     }
     catch (err) {
@@ -86,20 +91,132 @@ export async function runApp(input) {
             success: false,
             command_executed: fullCommand,
             message: `실행 실패: ${err instanceof Error ? err.message : String(err)}`,
-            runtime: "host"
+            runtime
+        };
+    }
+}
+function selectEntrypointCandidate(args) {
+    const context = getRunContext(args.run_id, args.basePath);
+    const entrypointsAbs = path.join(context.runs_path, "ingress", "entrypoints.msgpack");
+    if (!fs.existsSync(entrypointsAbs)) {
+        return {
+            ok: false,
+            message: "실행 후보 정보를 찾을 수 없습니다. 먼저 프로젝트 시작(ingress) 단계에서 사전 점검을 완료해주세요."
+        };
+    }
+    let decoded;
+    try {
+        const bytes = fs.readFileSync(entrypointsAbs);
+        decoded = decodeMsgpack(bytes);
+    }
+    catch {
+        return {
+            ok: false,
+            message: "실행 후보 정보를 읽을 수 없습니다. 사전 점검을 다시 실행해 주세요."
         };
     }
+    const doc = decoded;
+    const rawCandidates = args.mode === "test" ? doc.test_candidates : doc.run_candidates;
+    const candidates = normalizeEntrypointCandidates(rawCandidates);
+    if (candidates.length === 0) {
+        return {
+            ok: false,
+            message: "실행 후보가 없습니다. 사전 점검 결과를 확인하거나 실행 방법을 먼저 정리해 주세요."
+        };
+    }
+    const optionKey = typeof args.option_key === "string" ? args.option_key.trim() : "";
+    if (candidates.length >= 2) {
+        if (!["A", "B", "C"].includes(optionKey)) {
+            const choices = candidates
+                .slice(0, 3)
+                .map((c) => `${c.key}: ${c.label}`)
+                .join(" / ");
+            return {
+                ok: false,
+                message: `실행 후보가 여러 개입니다. option_key(A/B/C)로 하나를 선택해 주세요. (${choices})`
+            };
+        }
+        const picked = candidates.find((c) => c.key === optionKey);
+        if (!picked) {
+            return {
+                ok: false,
+                message: "선택한 실행 후보를 찾을 수 없습니다. A/B/C 중 다시 선택해 주세요."
+            };
+        }
+        return { ok: true, candidate: picked };
+    }
+    return { ok: true, candidate: candidates[0] };
+}
+function normalizeEntrypointCandidates(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        const obj = item;
+        const key = typeof obj?.key === "string" ? obj.key.trim() : "";
+        const label = typeof obj?.label === "string" ? obj.label.trim() : "";
+        const cmdArr = Array.isArray(obj?.command) ? obj.command.filter((x) => typeof x === "string") : [];
+        const command = cmdArr.map((x) => String(x).trim()).filter(Boolean);
+        if (!["A", "B", "C"].includes(key))
+            continue;
+        if (!label)
+            continue;
+        if (command.length === 0)
+            continue;
+        out.push({
+            key: key,
+            label,
+            kind: typeof obj?.kind === "string" ? obj.kind : undefined,
+            confidence: typeof obj?.confidence === "number" ? obj.confidence : undefined,
+            cwd: typeof obj?.cwd === "string" ? obj.cwd : undefined,
+            command,
+            evidence: Array.isArray(obj?.evidence) ? obj.evidence.filter((x) => typeof x === "string") : undefined
+        });
+    }
+    // Deterministic ordering: key order A/B/C
+    const order = { A: 1, B: 2, C: 3 };
+    return out.sort((a, b) => order[a.key] - order[b.key]);
+}
+function projectInfoFromCandidate(candidate, mode, customPort) {
+    const cmd = candidate.command[0] ?? "";
+    const args = candidate.command.slice(1);
+    const type = deriveProjectType(cmd);
+    const portDefault = type === "python" ? 8000 : 3000;
+    const port = customPort ?? portDefault;
+    const url = `http://localhost:${port}`;
+    // In v1: enforce repo-root execution for policy simplicity.
+    if (candidate.cwd && candidate.cwd !== ".") {
+        // Keep it deterministic and safe (monorepo support can be added later with explicit policy updates).
+        // Do not throw; return a safe default that will fail OPA or execution if misused.
+    }
+    // If mode=test and the candidate is a test runner, still keep url/port stable for output shape.
+    return { type, command: cmd, args, port, url };
+}
+function deriveProjectType(command) {
+    const c = (command ?? "").trim().toLowerCase();
+    if (!c)
+        return "unknown";
+    if (["npm", "pnpm", "yarn", "bun", "node", "npx"].includes(c))
+        return "node";
+    if (["python", "python3", "uvicorn"].includes(c))
+        return "python";
+    return "unknown";
 }
 function stableShortHash(input) {
     return createHash("sha256").update(input).digest("hex").slice(0, 12);
 }
+function isCurrentWorkOrder(value) {
+    return typeof value === "object" && value !== null;
+}
 function readCurrentWorkOrderRunId(basePath) {
     const workOrderPath = path.join(basePath, ".vibe", "state", "current_work_order.json");
     if (!fs.existsSync(workOrderPath))
         return null;
     try {
         const raw = JSON.parse(fs.readFileSync(workOrderPath, "utf-8"));
-        const runId = typeof raw?.run_id === "string" ? raw.run_id.trim() : "";
+        if (!isCurrentWorkOrder(raw))
+            return null;
+        const runId = typeof raw.run_id === "string" ? raw.run_id.trim() : "";
         if (!runId)
             return null;
         if (runId.includes("..") || runId.includes("/") || runId.includes("\\") || runId.includes("\0")) {
@@ -135,35 +252,36 @@ function writeJsonBestEffort(filePath, payload) {
         // ignore
     }
 }
-function normalizeOpaPath(value) {
-    return value.replace(/\\/g, "/");
-}
-function normalizeOpaPathRelative(basePath, value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        return "";
-    const absolute = path.isAbsolute(trimmed) ? trimmed : path.resolve(basePath, trimmed);
-    const relative = path.relative(basePath, absolute);
-    if (!relative)
-        return ".";
-    return normalizeOpaPath(relative);
-}
-function normalizeOpaPaths(basePath, values) {
-    const seen = new Set();
-    const out = [];
-    for (const raw of values) {
-        const normalized = normalizeOpaPathRelative(basePath, raw);
-        if (!normalized || seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        out.push(normalized);
-    }
-    return out;
+// P1-5: Path normalization functions consolidated into path-utils.ts
+// Aliases for backward compatibility within this file
+const normalizeOpaPath = toPosixPath;
+const normalizeOpaPathRelative = resolveRelativePosix;
+const normalizeOpaPaths = normalizePathArray;
+/**
+ * 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 +290,8 @@ function buildOpaPolicyInput(basePath, command, args, opts) {
             args,
             cwd,
             paths,
-            mounts
+            mounts,
+            script_name: scriptName
         },
         meta: {
             tool: "vibe_pm.run_app",
@@ -180,6 +299,26 @@ function buildOpaPolicyInput(basePath, command, args, opts) {
         }
     };
 }
+/**
+ * P1-6: Resolve OPA policy path with environment variable override support.
+ * VIBECODE_OPA_POLICY_PATH - Override default policy file path
+ * VIBECODE_OPA_POLICY_DIR - Override policy directory (appends /vibepm/run_app.rego)
+ */
+function resolveOpaPolicyPath(basePath) {
+    // Direct path override (highest priority)
+    const envPath = process.env.VIBECODE_OPA_POLICY_PATH;
+    if (envPath) {
+        return path.isAbsolute(envPath) ? envPath : path.resolve(basePath, envPath);
+    }
+    // Directory override (middle priority)
+    const envDir = process.env.VIBECODE_OPA_POLICY_DIR;
+    if (envDir) {
+        const baseDir = path.isAbsolute(envDir) ? envDir : path.resolve(basePath, envDir);
+        return path.join(baseDir, "vibepm", "run_app.rego");
+    }
+    // Default path
+    return path.join(basePath, "policy", "vibepm", "run_app.rego");
+}
 function evaluateOpaGate(basePath, input) {
     const runId = resolveRunIdForSecurity(basePath);
     const securityDir = resolveSecurityDir(basePath, runId);
@@ -187,7 +326,8 @@ function evaluateOpaGate(basePath, input) {
     const resultPath = securityDir ? path.join(securityDir, "policy_result.json") : null;
     if (inputPath)
         writeJsonBestEffort(inputPath, input);
-    const policyPath = path.join(basePath, "policy", "vibepm", "run_app.rego");
+    // P1-6: Support environment variable override for policy path
+    const policyPath = resolveOpaPolicyPath(basePath);
     if (!fs.existsSync(policyPath)) {
         const deny = {
             allow: false,
@@ -198,14 +338,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 +353,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)
@@ -256,11 +396,12 @@ function evaluateOpaGate(basePath, input) {
     }
 }
 function formatOpaBlockMessage(result) {
-    const text = `${result.reasons?.join(" ") ?? ""} ${(result.matched_rules ?? []).join(" ")}`.toLowerCase();
-    if (text.includes("missing")) {
+    // P1-4: Use centralized error patterns
+    const text = `${result.reasons?.join(" ") ?? ""} ${(result.matched_rules ?? []).join(" ")}`;
+    if (isOpaMissingError(text)) {
         return "OPA가 설치되어 있지 않거나 정책 파일이 없어 실행을 차단했습니다. OPA 설치/정책 파일을 확인하세요.";
     }
-    if (text.includes("eval_failed")) {
+    if (isOpaEvalFailedError(text)) {
         return "OPA 평가에 실패하여 안전을 위해 실행을 차단했습니다. OPA 상태를 확인하세요.";
     }
     return "OPA 정책에서 허용되지 않은 커맨드/경로입니다. 정책을 만족하도록 수정하세요.";
@@ -282,19 +423,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 +460,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/run_app_podman.js

@@ -1,14 +1,76 @@
 // adapters/mcp-ts/src/tools/vibe_pm/run_app_podman.ts
 // Pure helpers for Podman run_app path (testable without spawning Podman)
 import * as path from "node:path";
-export const CONTAINER_ENV_ALLOWLIST = new Set(["NODE_ENV", "PORT", "PYTHONUNBUFFERED", "CI"]);
+// P2-22: Environment variable filtering for container security
+// Allowlist: Safe environment variables that can be passed to containers
+export const CONTAINER_ENV_ALLOWLIST = new Set([
+    // Node.js
+    "NODE_ENV",
+    "PORT",
+    "HOST",
+    // Python
+    "PYTHONUNBUFFERED",
+    "PYTHONDONTWRITEBYTECODE",
+    // General
+    "CI",
+    "TZ",
+    "LANG",
+    "LC_ALL",
+    // Development
+    "DEBUG",
+    "LOG_LEVEL",
+    "VERBOSE",
+]);
+// Blocklist: Sensitive environment variables that must NEVER be passed
+const CONTAINER_ENV_BLOCKLIST = new Set([
+    // Secrets and credentials
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+    "GITHUB_TOKEN",
+    "GH_TOKEN",
+    "NPM_TOKEN",
+    "DOCKER_PASSWORD",
+    "DATABASE_URL",
+    "DB_PASSWORD",
+    "API_KEY",
+    "SECRET_KEY",
+    "PRIVATE_KEY",
+    "PASSWORD",
+    // Cloud provider credentials
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "AZURE_CLIENT_SECRET",
+    // SSH and authentication
+    "SSH_AUTH_SOCK",
+    "SSH_AGENT_PID",
+]);
+// Patterns for sensitive variable names (regex)
+const SENSITIVE_PATTERNS = [
+    /SECRET/i,
+    /PASSWORD/i,
+    /TOKEN$/i,
+    /API_KEY$/i,
+    /PRIVATE_KEY/i,
+    /CREDENTIAL/i,
+];
+function isSensitiveEnvVar(name) {
+    if (CONTAINER_ENV_BLOCKLIST.has(name))
+        return true;
+    return SENSITIVE_PATTERNS.some((pattern) => pattern.test(name));
+}
 export function filterContainerEnvAllowlist(env) {
     const out = {};
     if (!env)
         return out;
     for (const [k, v] of Object.entries(env)) {
-        if (CONTAINER_ENV_ALLOWLIST.has(k))
+        // P2-22: Block sensitive variables even if explicitly provided
+        if (isSensitiveEnvVar(k)) {
+            console.warn(`[run_app] Blocked sensitive env var: ${k}`);
+            continue;
+        }
+        if (CONTAINER_ENV_ALLOWLIST.has(k)) {
             out[k] = v;
+        }
     }
     return out;
 }