devez-vibe 1.3.9 → 1.3.11

package/bridge/claude-agent-sdk-bridge.mjs

@@ -1,19 +1,22 @@
 #!/usr/bin/env node
 
 import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 import { createReadStream } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import {
   deleteSession,
   forkSession,
-  getSessionInfo,
-  getSessionMessages,
-  listSessions,
-  startup,
-} from "@anthropic-ai/claude-agent-sdk";
+  getSessionInfo,
+  getSessionMessages,
+  filterEscalatingDefaultMode,
+  listSessions,
+  resolveSettings,
+  startup,
+} from "@anthropic-ai/claude-agent-sdk";
 
 const VERSION = process.env.DEVEZ_VIBE_VERSION || "dev";
 const sessions = new Map();
@@ -21,10 +24,10 @@ const sessions = new Map();
 // transcript under, so a session can be renamed mid-flight. Old id → live id,
 // which keeps ids the host already handed out (or wrote to disk) resolvable.
 const sessionAliases = new Map();
-const pendingHostRequests = new Map();
-const modelCatalogs = new Map();
-const CLAUDE_MODEL_ORDER = ["fable", "opus", "sonnet", "haiku"];
-let nextHostRequest = 1;
+const pendingHostRequests = new Map();
+const modelCatalogs = new Map();
+const CLAUDE_MODEL_ORDER = ["fable", "opus", "sonnet", "haiku"];
+let nextHostRequest = 1;
 
 class AsyncQueue {
   constructor() {
@@ -56,9 +59,9 @@ class AsyncQueue {
   }
 }
 
-function write(message) {
-  process.stdout.write(`${JSON.stringify(message)}\n`, "utf8");
-}
+function write(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`, "utf8");
+}
 
 function notify(method, params) {
   write({ method, params });
@@ -71,34 +74,34 @@ function rpcError(error) {
   };
 }
 
-function hostRequest(method, params, signal) {
-  const id = `claude-host-${nextHostRequest++}`;
-  return new Promise((resolve, reject) => {
+function hostRequest(method, params, signal) {
+  const id = `claude-host-${nextHostRequest++}`;
+  return new Promise((resolve, reject) => {
     const abort = () => {
       pendingHostRequests.delete(id);
       reject(new Error("사용자 입력 요청이 취소되었습니다."));
     };
     if (signal?.aborted) return abort();
     signal?.addEventListener("abort", abort, { once: true });
-    pendingHostRequests.set(id, {
-      resolve: (value) => {
-        signal?.removeEventListener("abort", abort);
-        resolve(value);
-      },
-      reject: (error) => {
-        signal?.removeEventListener("abort", abort);
-        reject(error);
-      },
-    });
-    try {
-      write({ id, method, params });
-    } catch (error) {
-      if (!pendingHostRequests.delete(id)) return;
-      signal?.removeEventListener("abort", abort);
-      reject(error);
-    }
-  });
-}
+    pendingHostRequests.set(id, {
+      resolve: (value) => {
+        signal?.removeEventListener("abort", abort);
+        resolve(value);
+      },
+      reject: (error) => {
+        signal?.removeEventListener("abort", abort);
+        reject(error);
+      },
+    });
+    try {
+      write({ id, method, params });
+    } catch (error) {
+      if (!pendingHostRequests.delete(id)) return;
+      signal?.removeEventListener("abort", abort);
+      reject(error);
+    }
+  });
+}
 
 function sanitizedEnvironment() {
   const env = { ...process.env };
@@ -168,7 +171,7 @@ function compactClaudeModelName(model) {
   return fallback || clean(model.displayName || model.resolvedModel || model.value);
 }
 
-function catalogEntry(model, defaultResolvedModel) {
+function catalogEntry(model, defaultResolvedModel) {
   const value = String(model.value || "");
   const resolved = String(model.resolvedModel || value);
   const efforts = model.supportsEffort && Array.isArray(model.supportedEffortLevels)
@@ -180,13 +183,14 @@ function catalogEntry(model, defaultResolvedModel) {
     model: visibleModel(value),
     displayName: compactClaudeModelName(model),
     defaultReasoningEffort: efforts.includes("high") ? "high" : efforts.at(-1) || "",
-    supportedReasoningEfforts: efforts.map((reasoningEffort) => ({ reasoningEffort })),
-    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
+    supportedReasoningEfforts: efforts.map((reasoningEffort) => ({ reasoningEffort })),
+    supportsAutoMode: Boolean(model.supportsAutoMode),
+    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
     ...(contextWindow > 0 ? { contextWindow } : {}),
   };
 }
 
-async function loadModelCatalog(params) {
+async function loadModelCatalog(params) {
   const cacheKey = `${params.claudePath || "claude"}\n${params.cwd || process.cwd()}`;
   if (modelCatalogs.has(cacheKey)) return modelCatalogs.get(cacheKey);
   const pending = (async () => {
@@ -207,18 +211,18 @@ async function loadModelCatalog(params) {
     })();
     try {
       const models = await agentQuery.supportedModels();
-      const defaultResolvedModel = String(
-        models.find((model) => model.value === "default")?.resolvedModel || "",
-      );
-      models.sort((left, right) => {
-        const leftFamily = String(left.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
-        const rightFamily = String(right.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
-        const leftOrder = CLAUDE_MODEL_ORDER.indexOf(leftFamily);
-        const rightOrder = CLAUDE_MODEL_ORDER.indexOf(rightFamily);
-        return (leftOrder < 0 ? CLAUDE_MODEL_ORDER.length : leftOrder)
-          - (rightOrder < 0 ? CLAUDE_MODEL_ORDER.length : rightOrder);
-      });
-      return {
+      const defaultResolvedModel = String(
+        models.find((model) => model.value === "default")?.resolvedModel || "",
+      );
+      models.sort((left, right) => {
+        const leftFamily = String(left.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
+        const rightFamily = String(right.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
+        const leftOrder = CLAUDE_MODEL_ORDER.indexOf(leftFamily);
+        const rightOrder = CLAUDE_MODEL_ORDER.indexOf(rightFamily);
+        return (leftOrder < 0 ? CLAUDE_MODEL_ORDER.length : leftOrder)
+          - (rightOrder < 0 ? CLAUDE_MODEL_ORDER.length : rightOrder);
+      });
+      return {
         data: models
           .filter((model) => model.value && model.value !== "default")
           .map((model) => catalogEntry(model, defaultResolvedModel)),
@@ -294,7 +298,14 @@ function adoptSessionId(session, incoming) {
   });
 }
 
-const PERMISSION_MODES = ["default", "acceptEdits", "plan", "auto", "bypassPermissions"];
+const PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "auto",
+  "dontAsk",
+  "bypassPermissions",
+];
 
 function permissionMode(requested, fallback = "default") {
   const mode = String(requested || "");
@@ -303,30 +314,173 @@ function permissionMode(requested, fallback = "default") {
 
 // Moves a live session onto a mode the badge picked. A rejected mode — policy
 // disables bypass, say — leaves the session on the one it already had.
-async function applyPermissionMode(session, requested) {
-  const mode = permissionMode(requested, session.permissionMode || "default");
-  if (mode === session.permissionMode) return;
-  try {
-    await session.query.setPermissionMode(mode);
-    session.permissionMode = mode;
-  } catch (error) {
-    notify("claude/permissionMode/rejected", {
-      threadId: visibleSession(session.id),
-      permissionMode: mode,
-      message: error?.message || String(error),
-    });
-  }
-}
+async function applyPermissionMode(session, requested) {
+  const mode = permissionMode(requested, session.permissionMode || "default");
+  if (mode === session.permissionMode) return null;
+  try {
+    await session.query.setPermissionMode(mode);
+    session.permissionMode = mode;
+    return null;
+  } catch (error) {
+    return error?.message || String(error);
+  }
+}
+
+async function claudePermissionStatus(params) {
+  const resolved = await resolveSettings({
+    cwd: params.cwd || process.cwd(),
+    settingSources: ["user", "project", "local"],
+  });
+  const effective = filterEscalatingDefaultMode(resolved);
+  const permissions = effective.permissions || {};
+  const bypassAccepted = effective.skipDangerousModePermissionPrompt === true
+    || effective.bypassPermissionsModeAccepted === true;
+  const bypassAvailable = permissions.disableBypassPermissionsMode !== "disable" && bypassAccepted;
+  const autoDisabled = effective.disableAutoMode === "disable";
+  let defaultMode = permissionMode(permissions.defaultMode);
+  if ((defaultMode === "bypassPermissions" && !bypassAvailable)
+      || (defaultMode === "auto" && autoDisabled)) defaultMode = "default";
+  const rules = [];
+  const directories = [];
+  for (const source of resolved.sources) {
+    const sourcePermissions = source.settings?.permissions || {};
+    for (const behavior of ["allow", "ask", "deny"]) {
+      for (const rule of Array.isArray(sourcePermissions[behavior])
+        ? sourcePermissions[behavior]
+        : []) {
+        rules.push({
+          behavior,
+          rule: String(rule),
+          source: source.source,
+          path: source.path || null,
+          mutable: ["user", "project", "local"].includes(source.source),
+        });
+      }
+    }
+    for (const directory of Array.isArray(sourcePermissions.additionalDirectories)
+      ? sourcePermissions.additionalDirectories
+      : []) {
+      directories.push({
+        directory: String(directory),
+        source: source.source,
+        path: source.path || null,
+        mutable: ["user", "project", "local"].includes(source.source),
+      });
+    }
+  }
+  const denials = [...sessions.values()]
+    .filter((session) => session.cwd === (params.cwd || process.cwd()))
+    .flatMap((session) => session.permissionDenials || [])
+    .slice(-20)
+    .reverse();
+  return {
+    defaultMode,
+    bypassAvailable,
+    autoDisabled,
+    rulesLocked: effective.allowManagedPermissionRulesOnly === true,
+    rules,
+    directories,
+    denials,
+  };
+}
+
+function permissionSettingsPath(cwd, destination) {
+  if (destination === "user") {
+    return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "settings.json");
+  }
+  if (destination === "project") return join(cwd, ".claude", "settings.json");
+  if (destination === "local") return join(cwd, ".claude", "settings.local.json");
+  throw new Error(`지원하지 않는 Claude 권한 설정 범위: ${destination}`);
+}
+
+async function updateClaudePermission(params) {
+  const cwd = params.cwd || process.cwd();
+  const status = await claudePermissionStatus({ cwd });
+  if (status.rulesLocked) {
+    throw new Error("관리 정책에서 사용자·프로젝트 권한 규칙 변경을 비활성화했습니다.");
+  }
+  const destination = String(params.destination || "project");
+  const path = permissionSettingsPath(cwd, destination);
+  let settings = {};
+  try {
+    settings = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
+  if (!settings.permissions || typeof settings.permissions !== "object"
+      || Array.isArray(settings.permissions)) settings.permissions = {};
+
+  const action = String(params.action || "");
+  const behavior = String(params.behavior || "");
+  const key = behavior === "directory" ? "additionalDirectories" : behavior;
+  if (!["allow", "ask", "deny", "additionalDirectories"].includes(key)) {
+    throw new Error(`지원하지 않는 Claude 권한 규칙 종류: ${behavior}`);
+  }
+  const value = String(params.value || "").trim();
+  if (!value) throw new Error("빈 Claude 권한 규칙은 저장할 수 없습니다.");
+  const values = Array.isArray(settings.permissions[key])
+    ? settings.permissions[key].map(String)
+    : [];
+  if (action === "add" && !values.includes(value)) values.push(value);
+  else if (action === "remove") {
+    const index = values.indexOf(value);
+    if (index >= 0) values.splice(index, 1);
+  } else if (action !== "add") {
+    throw new Error(`지원하지 않는 Claude 권한 규칙 작업: ${action}`);
+  }
+  settings.permissions[key] = values;
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  return claudePermissionStatus({ cwd });
+}
+
+async function setClaudeAutoModeDisabled(params) {
+  const cwd = params.cwd || process.cwd();
+  const path = permissionSettingsPath(cwd, "user");
+  let settings = {};
+  try {
+    settings = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
+  if (params.disabled === false) delete settings.disableAutoMode;
+  else settings.disableAutoMode = "disable";
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  return claudePermissionStatus({ cwd });
+}
+
+async function retryClaudePermission(params) {
+  const session = lookupSession(params.sessionId);
+  if (!session) throw new Error("재시도할 Claude 세션을 찾을 수 없습니다.");
+  const tool = String(params.tool || "tool");
+  const input = params.input && typeof params.input === "object" ? params.input : {};
+  const previousMode = session.permissionMode;
+  return startPrompt({
+    sessionId: session.id,
+    permissionMode: previousMode === "auto" ? "default" : previousMode,
+    restorePermissionMode: previousMode === "auto" ? "auto" : null,
+    input: [{
+      type: "text",
+      text: [
+        `The user selected the denied ${tool} action in /permissions and asked to retry it.`,
+        "Retry that action now. A manual permission prompt will be shown before it runs.",
+        `Original tool input: ${JSON.stringify(input)}`,
+      ].join("\n"),
+    }],
+  });
+}
 
 function makeOptions(params, sessionId, resume) {
   const options = {
     cwd: params.cwd || process.cwd(),
     includePartialMessages: true,
-    permissionMode: permissionMode(params.permissionMode),
-    // Not a mode, a capability: the SDK refuses `bypassPermissions` outright
-    // unless the session was started with this. Devez Vibe already auto-allows
-    // tools through `canUseTool`, so allowing the mode to be *reachable* grants
-    // nothing the session did not already have.
+    permissionMode: permissionMode(params.permissionMode),
+    // Not a mode, a capability: the SDK refuses `bypassPermissions` outright
+    // unless the session was started with this. The UI exposes it only after
+    // Claude's resolved settings and acknowledgement make the mode available.
     allowDangerouslySkipPermissions: true,
     enableFileCheckpointing: true,
     persistSession: true,
@@ -352,7 +506,7 @@ function makeOptions(params, sessionId, resume) {
   return options;
 }
 
-async function startAgentQuery(prompt, options) {
+async function startAgentQuery(prompt, options) {
   const warm = await startup({ options });
   try {
     return warm.query(prompt);
@@ -360,7 +514,29 @@ async function startAgentQuery(prompt, options) {
     warm.close();
     throw error;
   }
-}
+}
+
+function permissionSuggestionLabel(suggestions) {
+  if (!Array.isArray(suggestions) || !suggestions.length) return null;
+  const rules = suggestions.flatMap((suggestion) =>
+    Array.isArray(suggestion.rules)
+      ? suggestion.rules.map((rule) => rule.ruleContent
+        ? `${rule.toolName}(${rule.ruleContent})`
+        : String(rule.toolName || ""))
+      : []);
+  const directories = suggestions.flatMap((suggestion) =>
+    Array.isArray(suggestion.directories) ? suggestion.directories.map(String) : []);
+  const values = [...new Set([...rules, ...directories].filter(Boolean))];
+  const destinations = new Set(suggestions.map((suggestion) => suggestion.destination));
+  const scope = destinations.has("userSettings")
+    ? "모든 프로젝트에서"
+    : destinations.has("projectSettings") || destinations.has("localSettings")
+      ? "이 프로젝트에서"
+      : "이번 세션에서";
+  return values.length
+    ? `${scope} 항상 허용: ${values.join(", ")}`
+    : `${scope} 다시 묻지 않기`;
+}
 
 async function requestToolPermission(toolName, input, permission) {
   if (toolName === "AskUserQuestion") {
@@ -375,29 +551,29 @@ async function requestToolPermission(toolName, input, permission) {
       isOther: true,
       multiSelect: Boolean(question.multiSelect),
     }));
-    const requestQuestions = () => hostRequest(
-      "item/tool/requestUserInput",
-      // Keep model-provided text out of the NDJSON envelope. This protects
-      // Korean text, backslashes, and malformed Unicode from a partial escape
-      // corrupting the request line before the host can open its dialog.
-      {
-        encoding: "base64-json",
-        payload: Buffer.from(JSON.stringify({ questions }), "utf8").toString("base64"),
-      },
-      permission.signal,
-    );
-    let response;
-    try {
-      response = await requestQuestions();
-    } catch (error) {
-      if (!isQuestionDeliveryError(error)) throw error;
-      try {
-        response = await requestQuestions();
-      } catch (retryError) {
-        if (!isQuestionDeliveryError(retryError)) throw retryError;
-        return { behavior: "deny", message: questionFallbackMessage(questions) };
-      }
-    }
+    const requestQuestions = () => hostRequest(
+      "item/tool/requestUserInput",
+      // Keep model-provided text out of the NDJSON envelope. This protects
+      // Korean text, backslashes, and malformed Unicode from a partial escape
+      // corrupting the request line before the host can open its dialog.
+      {
+        encoding: "base64-json",
+        payload: Buffer.from(JSON.stringify({ questions }), "utf8").toString("base64"),
+      },
+      permission.signal,
+    );
+    let response;
+    try {
+      response = await requestQuestions();
+    } catch (error) {
+      if (!isQuestionDeliveryError(error)) throw error;
+      try {
+        response = await requestQuestions();
+      } catch (retryError) {
+        if (!isQuestionDeliveryError(retryError)) throw retryError;
+        return { behavior: "deny", message: questionFallbackMessage(questions) };
+      }
+    }
     const answers = {};
     for (let index = 0; index < questions.length; index += 1) {
       const selected = response?.answers?.[`q${index}`]?.answers;
@@ -410,38 +586,43 @@ async function requestToolPermission(toolName, input, permission) {
     return { behavior: "allow", updatedInput: { ...input, answers } };
   }
 
-  // Plan mode only means anything if leaving it is the user's call — the CLI
-  // shows the plan and waits. The blanket allow below would answer for them.
-  const planApproval = toolName === "ExitPlanMode";
-
-  // Devez Vibe runs in its existing full-access profile. Claude's callback is
-  // still kept so AskUserQuestion and explicit user-authored ask rules reach UI.
-  if (!permission.matchedAskRule && !planApproval) {
-    return { behavior: "allow", updatedInput: input };
-  }
-
-  let method = "item/permissions/requestApproval";
-  let params = {
-    reason: permission.decisionReason || permission.description || permission.title,
-    permissions: { tool: toolName, blockedPath: permission.blockedPath },
-  };
-  if (planApproval) {
-    params = {
-      reason: input.plan || permission.description || "계획대로 진행할까요?",
-      permissions: { tool: toolName },
-    };
-  } else if (toolName === "Bash") {
-    method = "item/commandExecution/requestApproval";
-    params = {
-      command: input.command || "command",
-      cwd: input.cwd,
-      reason: permission.decisionReason || permission.description,
+  // Claude calls this callback only after its selected mode and permission rules
+  // decide that a human answer is needed. Forward every such request to the host;
+  // auto-allowing the ordinary cases here would silently defeat default/auto mode.
+  const planApproval = toolName === "ExitPlanMode";
+  const persistentApprovalLabel = permissionSuggestionLabel(permission.suggestions);
+  const common = {
+    claudePermission: true,
+    title: permission.title || permission.displayName,
+    persistentApprovalLabel,
+  };
+
+  let method = "item/permissions/requestApproval";
+  let params = {
+    ...common,
+    reason: permission.decisionReason || permission.description || permission.title,
+    permissions: { tool: toolName, blockedPath: permission.blockedPath },
+  };
+  if (planApproval) {
+    params = {
+      ...common,
+      reason: input.plan || permission.description || "계획대로 진행할까요?",
+      permissions: { tool: toolName },
+    };
+  } else if (toolName === "Bash") {
+    method = "item/commandExecution/requestApproval";
+    params = {
+      ...common,
+      command: input.command || "command",
+      cwd: input.cwd,
+      reason: permission.decisionReason || permission.description,
     };
   } else if (["Edit", "Write", "NotebookEdit"].includes(toolName)) {
-    method = "item/fileChange/requestApproval";
-    params = {
-      grantRoot: permission.blockedPath || input.file_path || input.notebook_path,
-      reason: permission.decisionReason || permission.description,
+    method = "item/fileChange/requestApproval";
+    params = {
+      ...common,
+      grantRoot: permission.blockedPath || input.file_path || input.notebook_path,
+      reason: permission.decisionReason || permission.description,
     };
   }
   const response = await hostRequest(method, params, permission.signal);
@@ -455,28 +636,210 @@ async function requestToolPermission(toolName, input, permission) {
       ? { updatedPermissions: permission.suggestions }
       : {}),
   };
-}
-
-function isQuestionDeliveryError(error) {
-  return error?.code === -32700
-    || String(error?.message || error).includes("사용자 입력 화면에 전달하지 못했습니다");
-}
-
-function questionFallbackMessage(questions) {
-  const text = questions.map((question, index) => {
-    const options = question.options
-      .map((option, optionIndex) => `${optionIndex + 1}. ${option.label}`)
-      .join(" / ");
-    return `${index + 1}. ${question.question}${options ? ` (${options})` : ""}`;
-  }).join("\n");
-  return [
-    "사용자 입력 창을 두 번 표시하지 못했습니다.",
-    "도구를 다시 호출하지 말고 다음 질문을 일반 텍스트로 사용자에게 제시한 뒤 답변을 기다리세요:",
-    text,
-  ].join("\n");
-}
-
-async function createSession(params, resumeId) {
+}
+
+function runClaudeCommand(params, args) {
+  const executable = String(params.claudePath || "claude");
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, args, {
+      cwd: params.cwd || process.cwd(),
+      env: sanitizedEnvironment(),
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.once("error", reject);
+    child.once("close", (code) => {
+      const output = Buffer.concat(stdout).toString("utf8").trim();
+      const detail = Buffer.concat(stderr).toString("utf8").trim();
+      if (code === 0) resolve(output);
+      else reject(new Error(detail || output || `Claude 명령이 종료 코드 ${code}로 실패했습니다.`));
+    });
+  });
+}
+
+async function runClaudeJson(params, args) {
+  const output = await runClaudeCommand(params, args);
+  try { return output ? JSON.parse(output) : null; }
+  catch (error) {
+    throw new Error(`Claude 플러그인 응답을 해석하지 못했습니다: ${error.message}`);
+  }
+}
+
+function splitPluginId(id, fallbackMarketplace = "local") {
+  const value = String(id || "");
+  const separator = value.lastIndexOf("@");
+  if (separator <= 0 || separator === value.length - 1) {
+    return { name: value || "plugin", marketplace: fallbackMarketplace };
+  }
+  return { name: value.slice(0, separator), marketplace: value.slice(separator + 1) };
+}
+
+function claudePluginValue(available, installed) {
+  const id = String(available?.pluginId || installed?.id || "plugin");
+  const parts = splitPluginId(id, available?.marketplaceName);
+  const displayName = String(available?.name || parts.name);
+  const description = String(available?.description || "");
+  const mcpServers = installed?.mcpServers && typeof installed.mcpServers === "object"
+    ? Object.keys(installed.mcpServers)
+    : [];
+  const capabilities = [];
+  if (mcpServers.length) capabilities.push(`${mcpServers.length} MCP servers`);
+  return {
+    id,
+    // Keep the marketplace-qualified id as the action target. The display name
+    // remains short, so typed searches still resolve the same way as Claude CLI.
+    name: id,
+    description,
+    installed: Boolean(installed),
+    enabled: Boolean(installed?.enabled),
+    availability: "AVAILABLE",
+    installPolicy: "USER_INSTALLABLE",
+    mustShowInstallationInterstitial: true,
+    interface: {
+      displayName,
+      shortDescription: description,
+      developerName: parts.marketplace,
+      capabilities,
+    },
+  };
+}
+
+function buildClaudePluginCatalog(installed, available, marketplaces) {
+  const groups = new Map();
+  const ensureGroup = (name, path = null) => {
+    const key = String(name || "local");
+    if (!groups.has(key)) {
+      groups.set(key, {
+        name: key,
+        ...(path ? { path } : {}),
+        interface: { displayName: key },
+        plugins: [],
+      });
+    } else if (path) {
+      groups.get(key).path = path;
+    }
+    return groups.get(key);
+  };
+  for (const marketplace of Array.isArray(marketplaces) ? marketplaces : []) {
+    ensureGroup(marketplace.name, marketplace.installLocation);
+  }
+
+  const installedById = new Map();
+  for (const plugin of Array.isArray(installed) ? installed : []) {
+    if (plugin?.id && !installedById.has(plugin.id)) installedById.set(plugin.id, plugin);
+  }
+  const seen = new Set();
+  for (const plugin of Array.isArray(available) ? available : []) {
+    const id = String(plugin?.pluginId || "");
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    const parts = splitPluginId(id, plugin.marketplaceName);
+    ensureGroup(plugin.marketplaceName || parts.marketplace)
+      .plugins.push(claudePluginValue(plugin, installedById.get(id)));
+  }
+  for (const plugin of installedById.values()) {
+    if (seen.has(plugin.id)) continue;
+    const parts = splitPluginId(plugin.id);
+    ensureGroup(parts.marketplace).plugins.push(claudePluginValue(null, plugin));
+  }
+  for (const group of groups.values()) {
+    group.plugins.sort((left, right) => left.interface.displayName.localeCompare(right.interface.displayName));
+  }
+  return { marketplaces: [...groups.values()], marketplaceLoadErrors: [] };
+}
+
+async function claudePluginCatalog(params, installedOnly = false) {
+  const pluginArgs = installedOnly
+    ? ["plugin", "list", "--json"]
+    : ["plugin", "list", "--available", "--json"];
+  const [plugins, marketplaces] = await Promise.all([
+    runClaudeJson(params, pluginArgs),
+    runClaudeJson(params, ["plugin", "marketplace", "list", "--json"]),
+  ]);
+  const installed = installedOnly ? plugins : plugins?.installed;
+  const available = installedOnly ? [] : plugins?.available;
+  return buildClaudePluginCatalog(installed, available, marketplaces);
+}
+
+async function installedClaudePlugin(params, id) {
+  const plugins = await runClaudeJson(params, ["plugin", "list", "--json"]);
+  return (Array.isArray(plugins) ? plugins : []).find((plugin) => plugin?.id === id);
+}
+
+async function claudePluginDetail(params) {
+  const requested = String(params.pluginName || params.pluginId || "");
+  const raw = await runClaudeJson(params, ["plugin", "list", "--available", "--json"]);
+  const installed = (raw?.installed || []).find((plugin) => plugin?.id === requested);
+  const available = (raw?.available || []).find((plugin) => plugin?.pluginId === requested);
+  const entry = claudePluginValue(available, installed);
+  const skills = [];
+  if (installed?.installPath) {
+    try {
+      for (const child of await readdir(join(installed.installPath, "skills"), { withFileTypes: true })) {
+        if (child.isDirectory()) skills.push({ name: child.name });
+      }
+    } catch { /* Plugins do not have to provide skills. */ }
+  }
+  const mcpServers = installed?.mcpServers && typeof installed.mcpServers === "object"
+    ? Object.keys(installed.mcpServers).map((name) => ({ name }))
+    : [];
+  return {
+    plugin: {
+      summary: entry.interface.shortDescription,
+      description: entry.description,
+      skills,
+      mcpServers,
+      apps: [],
+      hooks: [],
+      scheduledTasks: [],
+    },
+  };
+}
+
+async function claudeSkills(params) {
+  const installed = await runClaudeJson(params, ["plugin", "list", "--json"]);
+  const skills = [];
+  for (const plugin of Array.isArray(installed) ? installed : []) {
+    if (!plugin?.enabled || !plugin.installPath) continue;
+    try {
+      for (const child of await readdir(join(plugin.installPath, "skills"), { withFileTypes: true })) {
+        if (!child.isDirectory()) continue;
+        skills.push({
+          name: child.name,
+          path: join(plugin.installPath, "skills", child.name, "SKILL.md"),
+          description: `${plugin.id} plugin skill`,
+          enabled: true,
+        });
+      }
+    } catch { /* Plugins do not have to provide skills. */ }
+  }
+  return { data: [{ cwd: params.cwd || process.cwd(), skills }] };
+}
+
+function isQuestionDeliveryError(error) {
+  return error?.code === -32700
+    || String(error?.message || error).includes("사용자 입력 화면에 전달하지 못했습니다");
+}
+
+function questionFallbackMessage(questions) {
+  const text = questions.map((question, index) => {
+    const options = question.options
+      .map((option, optionIndex) => `${optionIndex + 1}. ${option.label}`)
+      .join(" / ");
+    return `${index + 1}. ${question.question}${options ? ` (${options})` : ""}`;
+  }).join("\n");
+  return [
+    "사용자 입력 창을 두 번 표시하지 못했습니다.",
+    "도구를 다시 호출하지 말고 다음 질문을 일반 텍스트로 사용자에게 제시한 뒤 답변을 기다리세요:",
+    text,
+  ].join("\n");
+}
+
+async function createSession(params, resumeId) {
   const id = resumeId || randomUUID();
   const queue = new AsyncQueue();
   const session = {
@@ -494,7 +857,8 @@ async function createSession(params, resumeId) {
     turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
-    tools: new Map(),
+    tools: new Map(),
+    permissionDenials: [],
     tasks: new Map(),
     planCreatePending: false,
     subagents: new Map(),
@@ -1400,9 +1764,16 @@ function toolOutput(content, structured) {
   return content == null ? "" : JSON.stringify(content, null, 2);
 }
 
-async function processResult(session, message) {
-  if (!session.turn) return;
-  const interrupted = session.turn.interruptRequested === true;
+async function processResult(session, message) {
+  if (!session.turn) return;
+  for (const denial of Array.isArray(message.permission_denials) ? message.permission_denials : []) {
+    rememberPermissionDenial(session, {
+      tool: denial.tool_name,
+      toolUseId: denial.tool_use_id,
+      input: denial.tool_input,
+    });
+  }
+  const interrupted = session.turn.interruptRequested === true;
   const totals = [...Object.values(message.modelUsage || {})].reduce((sum, usage) => ({
     inputTokens: sum.inputTokens + Number(usage.inputTokens || 0) + Number(usage.cacheReadInputTokens || 0) + Number(usage.cacheCreationInputTokens || 0),
     cachedInputTokens: sum.cachedInputTokens + Number(usage.cacheReadInputTokens || 0),
@@ -1421,17 +1792,42 @@ async function processResult(session, message) {
       modelContextWindow: totals.contextWindow || session.lastContextWindow || undefined,
     },
   });
-  const error = message.is_error && !interrupted
+  const error = message.is_error && !interrupted
     ? { message: message.errors?.join("\n") || message.stop_reason || "Claude 실행 실패" }
     : null;
-  finishTurn(session, error, message.duration_ms);
+  finishTurn(session, error, message.duration_ms);
+  if (session.restorePermissionMode) {
+    const restore = session.restorePermissionMode;
+    session.restorePermissionMode = null;
+    await applyPermissionMode(session, restore);
+  }
   notify("claude/account/updated", {
     threadId: session.id,
     account: await safeAccount(session.query),
     usage: await safeUsage(session.query),
   });
-  await runPendingPrompt(session);
-}
+  await runPendingPrompt(session);
+}
+
+function rememberPermissionDenial(session, denial) {
+  const toolUseId = String(denial.toolUseId || "");
+  const existing = toolUseId
+    ? session.permissionDenials.find((candidate) => candidate.toolUseId === toolUseId)
+    : null;
+  if (existing) {
+    existing.tool = String(denial.tool || existing.tool || "Tool");
+    existing.reason = String(denial.reason || existing.reason || "");
+    if (denial.input && typeof denial.input === "object") existing.input = denial.input;
+    return;
+  }
+  session.permissionDenials.push({
+    tool: String(denial.tool || "Tool"),
+    toolUseId,
+    reason: String(denial.reason || ""),
+    input: denial.input && typeof denial.input === "object" ? denial.input : {},
+  });
+  if (session.permissionDenials.length > 20) session.permissionDenials.shift();
+}
 
 // The turn that was waiting starts on its own, so the host sees it exactly like a
 // prompt sent the moment the previous turn ended.
@@ -1474,10 +1870,16 @@ async function consume(session) {
       await processStreamEvent(session, message);
     } else if (message.type === "assistant") processAssistant(session, message);
     else if (message.type === "user") processUser(session, message);
-    else if (message.type === "result") await processResult(session, message);
-    else if (message.type === "system" && message.subtype === "compact_boundary") {
-      notify("thread/compacted", { threadId: session.id });
-    } else if (message.type === "rate_limit_event") {
+    else if (message.type === "result") await processResult(session, message);
+    else if (message.type === "system" && message.subtype === "compact_boundary") {
+      notify("thread/compacted", { threadId: session.id });
+    } else if (message.type === "system" && message.subtype === "permission_denied") {
+      rememberPermissionDenial(session, {
+        tool: message.tool_name,
+        toolUseId: message.tool_use_id,
+        reason: message.decision_reason || message.decision_reason_type,
+      });
+    } else if (message.type === "rate_limit_event") {
       notify("claude/account/updated", { threadId: session.id, rateLimitInfo: message.rate_limit_info });
     } else if (message.type === "system" && message.subtype === "api_retry") {
       notify("warning", { threadId: session.id, provider: "Claude", message: `Claude API 재시도 ${message.attempt}/${message.max_retries}` });
@@ -1553,8 +1955,19 @@ async function runPrompt(session, params) {
     await session.query.applyFlagSettings({ effortLevel: effort });
   }
   session.effort = effort;
-  await applyPermissionMode(session, params.permissionMode);
-  const content = await inputContent(params.input, params.handoffContext);
+  const permissionRejection = await applyPermissionMode(session, params.permissionMode);
+  if (permissionRejection) {
+    notify("claude/permissionMode/rejected", {
+      threadId: visibleSession(session.id),
+      permissionMode: params.permissionMode,
+      effectivePermissionMode: session.permissionMode,
+      message: permissionRejection,
+    });
+  }
+  if (params.restorePermissionMode) {
+    session.restorePermissionMode = permissionMode(params.restorePermissionMode);
+  }
+  const content = await inputContent(params.input, params.handoffContext);
   const turnId = beginTurn(session, params.input);
   session.queue.push({
     type: "user",
@@ -1825,13 +2238,74 @@ async function readableCwd(id, cwd) {
 
 async function dispatch(method, params = {}) {
   if (method === "model/list") return loadModelCatalog(params);
-  if (method === "session/permissionMode") {
-    const session = lookupSession(params.sessionId);
-    // A session that has not started yet picks the mode up from its first turn.
-    if (!session) return { permissionMode: permissionMode(params.permissionMode) };
-    await applyPermissionMode(session, params.permissionMode);
-    return { permissionMode: session.permissionMode };
+  if (method === "plugin/list") return claudePluginCatalog(params);
+  if (method === "plugin/installed") return claudePluginCatalog(params, true);
+  if (method === "plugin/read") return claudePluginDetail(params);
+  if (method === "plugin/install") {
+    const requested = String(params.pluginName || "");
+    const id = requested.includes("@") || !params.remoteMarketplaceName
+      ? requested
+      : `${requested}@${params.remoteMarketplaceName}`;
+    if (!id) throw new Error("설치할 Claude 플러그인 이름이 없습니다.");
+    await runClaudeCommand(params, ["plugin", "install", id, "--scope", "user"]);
+    return { pluginId: id, appsNeedingAuth: [] };
+  }
+  if (method === "plugin/uninstall") {
+    const id = String(params.pluginId || "");
+    if (!id) throw new Error("제거할 Claude 플러그인 이름이 없습니다.");
+    const installed = await installedClaudePlugin(params, id);
+    await runClaudeCommand(params, [
+      "plugin", "uninstall", id, "--scope", installed?.scope || "user",
+    ]);
+    return {};
+  }
+  if (method === "plugin/set-enabled") {
+    const id = String(params.pluginId || "");
+    if (!id) throw new Error("변경할 Claude 플러그인 이름이 없습니다.");
+    const installed = await installedClaudePlugin(params, id);
+    await runClaudeCommand(params, [
+      "plugin", params.enabled ? "enable" : "disable", id,
+      "--scope", installed?.scope || "user",
+    ]);
+    return { effectiveEnabled: Boolean(params.enabled) };
+  }
+  if (method === "marketplace/add") {
+    const ref = params.refName ? `@${params.refName}` : "";
+    const source = `${String(params.source || "")}${ref}`;
+    if (!source) throw new Error("추가할 Claude 마켓플레이스 주소가 없습니다.");
+    await runClaudeCommand(params, ["plugin", "marketplace", "add", source]);
+    return { alreadyAdded: false, installedRoot: source };
+  }
+  if (method === "marketplace/remove") {
+    const name = String(params.marketplaceName || "");
+    if (!name) throw new Error("제거할 Claude 마켓플레이스 이름이 없습니다.");
+    await runClaudeCommand(params, ["plugin", "marketplace", "remove", name]);
+    return {};
+  }
+  if (method === "marketplace/upgrade") {
+    const output = await runClaudeCommand(params, ["plugin", "marketplace", "update"]);
+    return { message: output, consideredRoots: ["Claude marketplaces"], errors: [] };
   }
+  if (method === "skills/list") return claudeSkills(params);
+  if (method === "app/list") return { data: [] };
+  if (method === "plugin/reload") {
+    return { message: "Claude 플러그인 설정을 다시 읽었습니다. 새 대화부터 적용됩니다." };
+  }
+  if (method === "permissions/status") return claudePermissionStatus(params);
+  if (method === "permissions/update") return updateClaudePermission(params);
+  if (method === "permissions/auto-mode") return setClaudeAutoModeDisabled(params);
+  if (method === "permissions/retry") return retryClaudePermission(params);
+  if (method === "session/permissionMode") {
+    const session = lookupSession(params.sessionId);
+    // A session that has not started yet picks the mode up from its first turn.
+    if (!session) return { permissionMode: permissionMode(params.permissionMode) };
+    session.restorePermissionMode = null;
+    const rejection = await applyPermissionMode(session, params.permissionMode);
+    return {
+      permissionMode: session.permissionMode,
+      ...(rejection ? { rejection } : {}),
+    };
+  }
   if (method === "session/start") {
     const { session, account, usage } = await createSession(params);
     return {
@@ -1984,7 +2458,29 @@ async function dispatch(method, params = {}) {
   throw new Error(`지원하지 않는 Claude 브리지 메서드: ${method}`);
 }
 
-async function runSelfTest() {
+async function runSelfTest() {
+  if (permissionMode("dontAsk") !== "dontAsk"
+    || permissionMode("not-a-mode", "auto") !== "auto") {
+    throw new Error("Claude permission mode self-test failed");
+  }
+  const pluginCatalog = buildClaudePluginCatalog(
+    [{ id: "cloudflare@official", enabled: true, scope: "user" }],
+    [{
+      pluginId: "cloudflare@official",
+      name: "cloudflare",
+      description: "Cloud tools",
+      marketplaceName: "official",
+    }],
+    [{ name: "official", installLocation: "/tmp/official" }],
+  );
+  const plugin = pluginCatalog.marketplaces[0]?.plugins[0];
+  if (plugin?.id !== "cloudflare@official"
+    || plugin?.name !== "cloudflare@official"
+    || plugin?.interface?.displayName !== "cloudflare"
+    || plugin?.installed !== true
+    || plugin?.enabled !== true) {
+    throw new Error(`Claude plugin catalogue self-test failed: ${JSON.stringify(pluginCatalog)}`);
+  }
   const user = (uuid, text) => ({
     type: "user",
     uuid,
@@ -2476,20 +2972,20 @@ lines.on("line", async (line) => {
     write({ method: "warning", params: { provider: "Claude", message: `Claude 브리지 JSON 해석 실패: ${error.message}` } });
     return;
   }
-  if (typeof message.id === "string" && ("result" in message || "error" in message)) {
-    const pending = pendingHostRequests.get(message.id);
-    if (pending) {
-      pendingHostRequests.delete(message.id);
-      if (message.error) {
-        const error = new Error(message.error.message || "호스트 요청이 거부되었습니다.");
-        error.code = message.error.code;
-        pending.reject(error);
-      } else {
-        pending.resolve(message.result ?? { decision: "decline" });
-      }
-    }
-    return;
-  }
+  if (typeof message.id === "string" && ("result" in message || "error" in message)) {
+    const pending = pendingHostRequests.get(message.id);
+    if (pending) {
+      pendingHostRequests.delete(message.id);
+      if (message.error) {
+        const error = new Error(message.error.message || "호스트 요청이 거부되었습니다.");
+        error.code = message.error.code;
+        pending.reject(error);
+      } else {
+        pending.resolve(message.result ?? { decision: "decline" });
+      }
+    }
+    return;
+  }
   if (typeof message.id !== "number" || typeof message.method !== "string") return;
   try { write({ id: message.id, result: await dispatch(message.method, message.params) }); }
   catch (error) { write({ id: message.id, error: rpcError(error) }); }

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "devez-vibe",
-  "version": "1.3.9",
-  "description": "Stable terminal UI for Codex and Claude Agent SDK",
-  "keywords": [
-    "codex",
-    "cli",
-    "tui",
-    "terminal",
-    "app-server",
-    "claude-agent-sdk"
-  ],
-  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
-  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
-  },
-  "license": "MIT",
-  "bin": {
-    "dvz": "bin/dvz.exe"
-  },
-  "files": [
-    "bin/dvz.exe",
-    "bridge/claude-agent-sdk-bridge.mjs",
-    "README.md",
-    "LICENSE"
-  ],
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.223"
-  }
-}
+{
+  "name": "devez-vibe",
+  "version": "1.3.11",
+  "description": "Stable terminal UI for Codex and Claude Agent SDK",
+  "keywords": [
+    "codex",
+    "cli",
+    "tui",
+    "terminal",
+    "app-server",
+    "claude-agent-sdk"
+  ],
+  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
+  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "dvz": "bin/dvz.exe"
+  },
+  "files": [
+    "bin/dvz.exe",
+    "bridge/claude-agent-sdk-bridge.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.223"
+  }
+}