@khalilgharbaoui/opencode-claude-code-plugin 0.27.2 → 0.28.1

package/dist/index.js

@@ -931,6 +931,13 @@ function formatStreamTimeoutNote(silenceMs) {
 ${STREAM_TIMEOUT_MARKER} The Claude Code CLI produced output and then went silent for ${seconds}s without finishing the turn, so it was closed without a result. The answer above may be incomplete.
 `;
 }
+var SILENT_TURN_MARKER = "\u258C **no reply:**";
+function formatSilentTurnNote(hadReasoning) {
+  const what = hadReasoning ? "Claude Code finished the turn after thinking but never wrote an answer" : "Claude Code finished the turn without writing anything or calling a tool";
+  return `
+${SILENT_TURN_MARKER} ${what}, so there is no reply above. Nothing failed and nothing is pending: send the message again, or rephrase it.
+`;
+}
 
 // src/plan-mode-question.ts
 var QUESTION_TOOL_NAME = "question";
@@ -1468,6 +1475,14 @@ function cliSupportsFastMode(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 1, patch: 220 });
 }
+function cliSupportsRestricted(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 258 });
+}
+function cliSupportsPermissionPrompts(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 263 });
+}
 function cliSupportsSideQuestion(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 1, patch: 258 });
@@ -1522,25 +1537,137 @@ import { EventEmitter } from "events";
 import * as fs from "fs";
 import * as os from "os";
 import * as path2 from "path";
-var PLUGIN_TMP_DIR = path2.join(
+var PLUGIN_TMP_PREFIX = "opencode-claude-code-";
+var PID_TMP_DIR = path2.join(
   os.tmpdir(),
-  `opencode-claude-code-${process.pid}`
+  `${PLUGIN_TMP_PREFIX}${process.pid}`
 );
+var currentDir = null;
+var createdDirs = /* @__PURE__ */ new Set();
 var registered = false;
-function pluginTmpDir() {
-  if (!fs.existsSync(PLUGIN_TMP_DIR)) {
-    fs.mkdirSync(PLUGIN_TMP_DIR, { recursive: true });
+function currentUid() {
+  return typeof process.getuid === "function" ? process.getuid() : void 0;
+}
+function untrustworthyReason(dir) {
+  let stat;
+  try {
+    stat = fs.lstatSync(dir);
+  } catch {
+    return null;
   }
-  if (!registered) {
-    registered = true;
-    process.on("exit", () => {
+  if (stat.isSymbolicLink()) return "path is a symlink";
+  if (!stat.isDirectory()) return "path is not a directory";
+  const uid = currentUid();
+  if (uid !== void 0 && stat.uid !== uid) {
+    return `directory is owned by uid ${stat.uid}, not ${uid}`;
+  }
+  return null;
+}
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+}
+function chooseDir() {
+  const reason = untrustworthyReason(PID_TMP_DIR);
+  if (!reason) return PID_TMP_DIR;
+  const fallback = fs.mkdtempSync(path2.join(os.tmpdir(), PLUGIN_TMP_PREFIX));
+  log.warn("refusing the pid-named scratch directory", {
+    path: PID_TMP_DIR,
+    reason,
+    fallback
+  });
+  return fallback;
+}
+function registerExitCleanup() {
+  if (registered) return;
+  registered = true;
+  process.on("exit", () => {
+    for (const dir of createdDirs) {
       try {
-        fs.rmSync(PLUGIN_TMP_DIR, { recursive: true, force: true });
+        fs.rmSync(dir, { recursive: true, force: true });
       } catch {
       }
+    }
+  });
+}
+var PID_DIR_NAME = /^opencode-claude-code-(\d+)$/;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function sweepStalePluginTmpDirs(keep) {
+  const removed = [];
+  if (process.env.OPENCODE_CLAUDE_CODE_NO_TMP_SWEEP === "1") return removed;
+  const root = os.tmpdir();
+  let entries;
+  try {
+    entries = fs.readdirSync(root);
+  } catch {
+    return removed;
+  }
+  const uid = currentUid();
+  const keepPath = keep ? path2.resolve(keep) : null;
+  for (const entry of entries) {
+    const match = PID_DIR_NAME.exec(entry);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    if (!Number.isSafeInteger(pid) || pid <= 0) continue;
+    if (pid === process.pid) continue;
+    const dir = path2.join(root, entry);
+    if (keepPath && path2.resolve(dir) === keepPath) continue;
+    let stat;
+    try {
+      stat = fs.lstatSync(dir);
+    } catch {
+      continue;
+    }
+    if (stat.isSymbolicLink() || !stat.isDirectory()) continue;
+    if (uid !== void 0 && stat.uid !== uid) continue;
+    if (isProcessAlive(pid)) continue;
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+      removed.push(dir);
+    } catch (err) {
+      log.debug("could not remove a stale scratch directory", {
+        dir,
+        error: String(err)
+      });
+    }
+  }
+  if (removed.length > 0) {
+    log.info("removed stale plugin scratch directories", {
+      count: removed.length,
+      dirs: removed
     });
   }
-  return PLUGIN_TMP_DIR;
+  return removed;
+}
+var swept = false;
+function sweepOnce(keep) {
+  if (swept) return;
+  swept = true;
+  try {
+    sweepStalePluginTmpDirs(keep);
+  } catch (err) {
+    log.warn("stale scratch directory sweep failed", { error: String(err) });
+  }
+}
+function pluginTmpDir() {
+  if (currentDir === null || untrustworthyReason(currentDir) !== null) {
+    currentDir = chooseDir();
+  }
+  ensureDir(currentDir);
+  createdDirs.add(currentDir);
+  registerExitCleanup();
+  sweepOnce(currentDir);
+  return currentDir;
 }
 
 // src/proxy-mcp.ts
@@ -2122,12 +2249,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         });
         let timer = null;
         const result = await new Promise(
-          (resolve5, reject2) => {
+          (resolve6, reject2) => {
             const entry = {
               id: callId,
               toolName,
               input,
-              resolve: resolve5,
+              resolve: resolve6,
               reject: reject2,
               channel
             };
@@ -2216,11 +2343,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       }
     }
   });
-  await new Promise((resolve5, reject2) => {
+  await new Promise((resolve6, reject2) => {
     server2.once("error", reject2);
     server2.listen(0, "127.0.0.1", () => {
       server2.off("error", reject2);
-      resolve5();
+      resolve6();
     });
   });
   const addr = server2.address();
@@ -2277,8 +2404,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         entry.reject(new Error(SERVER_CLOSED_MESSAGE));
       }
       pending.clear();
-      await new Promise((resolve5) => {
-        server2.close(() => resolve5());
+      await new Promise((resolve6) => {
+        server2.close(() => resolve6());
       });
       if (configFilePath) {
         try {
@@ -2433,10 +2560,10 @@ function resolveMcpProxyToolDefs(options) {
   return { defs, coveredServers };
 }
 function readBody(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -2744,6 +2871,99 @@ function clearCompression(sessionKey2) {
   compressions.delete(sessionKey2);
 }
 
+// src/types.ts
+var READ_ONLY_PERMISSION_MODE = "read-only";
+
+// src/permission-presets.ts
+var READ_ONLY_DISALLOWED_CLI_TOOLS = [
+  "Bash",
+  "Write",
+  "Edit",
+  "NotebookEdit",
+  "REPL",
+  "JavaScript",
+  "WebFetch"
+];
+var READ_ONLY_DENIED_PROXY_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "write",
+  "edit",
+  "webfetch",
+  "task",
+  "task_batch"
+]);
+function dedupe(names) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const trimmed = String(name).trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+function resolveReadOnly(settings, defaultProxyTools) {
+  const overridden = [];
+  if (settings.permissionMode !== void 0) {
+    overridden.push(
+      `permissionMode: "${settings.permissionMode}" is dropped; read-only sends --restricted instead, which is stricter than every mode except plan and incompatible with bypassPermissions`
+    );
+  }
+  if (settings.skipPermissions === true) {
+    overridden.push(
+      'skipPermissions: forced to false; the CLI exits with "bypassPermissions not supported in restricted mode" when both are passed'
+    );
+  }
+  if (settings.controlRequestBehavior === "allow") {
+    overridden.push(
+      'controlRequestBehavior: forced to "deny"; read-only answers every permission request the same way the CLI does under --permission-prompts none'
+    );
+  }
+  if (settings.controlRequestToolBehaviors !== void 0) {
+    overridden.push(
+      "controlRequestToolBehaviors: ignored; a per-tool allow would apply only on CLIs older than 2.1.263, so the preset would mean different things on different versions"
+    );
+  }
+  const requested = settings.proxyTools ?? defaultProxyTools;
+  const proxyTools = dedupe(requested).filter(
+    (name) => !READ_ONLY_DENIED_PROXY_TOOLS.has(name.toLowerCase())
+  );
+  const dropped = dedupe(requested).filter(
+    (name) => READ_ONLY_DENIED_PROXY_TOOLS.has(name.toLowerCase())
+  );
+  if (dropped.length > 0) {
+    overridden.push(
+      `proxyTools: dropped ${dropped.join(", ")}; those execute in opencode, where no Claude CLI flag reaches them`
+    );
+  }
+  return {
+    preset: "read-only",
+    permissionMode: READ_ONLY_PERMISSION_MODE,
+    skipPermissions: false,
+    proxyTools,
+    extraDisallowedTools: dedupe([
+      ...READ_ONLY_DISALLOWED_CLI_TOOLS,
+      ...settings.extraDisallowedTools ?? []
+    ]),
+    controlRequestBehavior: "deny",
+    controlRequestToolBehaviors: void 0,
+    overridden
+  };
+}
+function resolvePermissionPreset(settings, defaultProxyTools) {
+  const preset = settings.permissionPreset;
+  if (preset === void 0) return null;
+  if (preset === "read-only") return resolveReadOnly(settings, defaultProxyTools);
+  return { unknown: String(preset) };
+}
+function isUnknownPreset(resolved) {
+  return resolved !== null && "unknown" in resolved;
+}
+function isReadOnlyPermissionMode(mode) {
+  return mode === READ_ONLY_PERMISSION_MODE;
+}
+
 // src/side-question.ts
 import { randomUUID as randomUUID2 } from "crypto";
 var MAX_HISTORY_EXCHANGES = 20;
@@ -2847,7 +3067,7 @@ async function requestSideQuestion(activeProcess, question, options) {
     }
   });
   pendingProcesses.add(proc);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const event = `side-question:${requestId}`;
     let settled = false;
     let sent = false;
@@ -2902,7 +3122,7 @@ async function requestSideQuestion(activeProcess, question, options) {
       }
       settled = true;
       cleanup();
-      resolve5({ response: result.response, synthetic: result.synthetic });
+      resolve6({ response: result.response, synthetic: result.synthetic });
     };
     const timer = setTimeout(() => {
       fail(new Error(`/btw timed out after ${timeoutMs}ms.`), true);
@@ -3067,16 +3287,16 @@ function isTurnInFlight(ap) {
 }
 function awaitTurnIdle(ap, timeoutMs) {
   if (!ap.turnInFlight) return Promise.resolve(true);
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const wake = () => {
       clearTimeout(timer);
-      resolve5(true);
+      resolve6(true);
     };
     const timer = setTimeout(() => {
       const waiters = ap.turnIdleWaiters ?? [];
       const at = waiters.indexOf(wake);
       if (at >= 0) waiters.splice(at, 1);
-      resolve5(false);
+      resolve6(false);
     }, timeoutMs);
     (ap.turnIdleWaiters ??= []).push(wake);
   });
@@ -3195,14 +3415,14 @@ function hasProcessExited(proc) {
 }
 function waitForProcessExit(proc, timeoutMs) {
   if (hasProcessExited(proc)) return Promise.resolve(true);
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const onExit = () => {
       clearTimeout(timer);
-      resolve5(true);
+      resolve6(true);
     };
     const timer = setTimeout(() => {
       proc.off("exit", onExit);
-      resolve5(hasProcessExited(proc));
+      resolve6(hasProcessExited(proc));
     }, timeoutMs);
     proc.once("exit", onExit);
   });
@@ -3453,7 +3673,25 @@ function buildCliArgs(opts) {
   if (model) {
     args.push("--model", model);
   }
-  if (permissionMode) {
+  const readOnly = isReadOnlyPermissionMode(permissionMode);
+  if (readOnly) {
+    if (cliSupportsRestricted(cliVersion ?? null)) {
+      args.push("--restricted");
+    } else {
+      log.warn(
+        'permissionPreset "read-only": this claude CLI has no --restricted (2.1.258+), so file reads are not confined to the working directory. The mutating tools are still refused via --disallowedTools and every permission request is denied.',
+        { cliVersion: cliVersion?.raw ?? "unknown" }
+      );
+    }
+    if (cliSupportsPermissionPrompts(cliVersion ?? null)) {
+      args.push("--permission-prompts", "none");
+    } else {
+      log.warn(
+        `permissionPreset "read-only": this claude CLI has no --permission-prompts (2.1.263+), so permission requests are denied by the plugin's own can_use_tool handler instead of by the CLI. Same outcome, one layer fewer.`,
+        { cliVersion: cliVersion?.raw ?? "unknown" }
+      );
+    }
+  } else if (permissionMode) {
     args.push("--permission-mode", permissionMode);
   }
   if (includeSessionId) {
@@ -3490,7 +3728,7 @@ function buildCliArgs(opts) {
   if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
     args.push("--settings", JSON.stringify({ fastMode: true }));
   }
-  if (skipPermissions && permissionMode !== "plan") {
+  if (skipPermissions && permissionMode !== "plan" && !readOnly) {
     args.push("--dangerously-skip-permissions");
   }
   return args;
@@ -3642,7 +3880,7 @@ async function waitForSessionIdle(client, sessionID, options = {}) {
     if (options.stop?.()) return true;
     if (await sessionStatus(client, sessionID) !== "busy") return true;
     if (Date.now() - started >= timeoutMs) return false;
-    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 async function deliverAsideInline(client, sessionID, text, options = {}) {
@@ -3653,7 +3891,7 @@ async function deliverAsideInline(client, sessionID, text, options = {}) {
     if (emitAsideInline(sessionID, text)) return true;
     if (Date.now() - started >= timeoutMs) return false;
     if (await sessionStatus(client, sessionID) !== "busy") return false;
-    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 async function waitForAsideProcess(client, sessionID, options = {}) {
@@ -3674,7 +3912,7 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
       log.warn("btw: a turn is running but no claude process appeared for it", { sessionID, waitedMs });
       return void 0;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 async function settleSessionBusy(client, sessionID, active, options = {}) {
@@ -3686,7 +3924,7 @@ async function settleSessionBusy(client, sessionID, active, options = {}) {
     if (status === "busy") return true;
     if (status === "unknown") return isProcessBusy(active);
     if (Date.now() - started >= settleMs) return false;
-    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 function errorText(error) {
@@ -3733,10 +3971,10 @@ async function handleBtwCommand(client, input, options = {}) {
   let inlineDone = false;
   let markInlineDelivered = () => {
   };
-  const inlineDelivered = new Promise((resolve5) => {
+  const inlineDelivered = new Promise((resolve6) => {
     markInlineDelivered = () => {
       inlineDone = true;
-      resolve5("inline");
+      resolve6("inline");
     };
   });
   if (isSideQuestionPending(active)) {
@@ -4270,7 +4508,7 @@ async function settleSessionRunState(sessionID, options = {}) {
     if (state === "busy") return "busy";
     if (state !== "unknown") last = state;
     if (Date.now() - started >= windowMs) return last;
-    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 async function getRuntimeMcpStatus() {
@@ -4753,6 +4991,7 @@ var PLUGIN_NOTE_MARKERS = [
   RESULT_ERROR_MARKER,
   DOCTOR_MARKER,
   STREAM_TIMEOUT_MARKER,
+  SILENT_TURN_MARKER,
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER
 ];
@@ -6530,7 +6769,7 @@ function spawnInteractiveProcess(opts) {
 
 // src/prompts.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
+import { homedir as homedir6 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname5, join as join8 } from "path";
 function readPromptFileIfPresent(path10) {
@@ -6650,9 +6889,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path10 = join8(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
+  const path10 = join8(pluginTmpDir(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
-    writeFileSync4(path10, content, "utf8");
+    writeFileSync4(path10, content, { encoding: "utf8", mode: 384 });
     return path10;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -6753,6 +6992,14 @@ function shouldAutoContinueIncompleteTurn(state, snapshot) {
   }
   return { continue: true, reason: "non-final-progress" };
 }
+function isSilentTurn(snapshot) {
+  if (snapshot.enabled === false) return false;
+  if (snapshot.compactionMode) return false;
+  if (snapshot.isError) return false;
+  if (snapshot.aborted) return false;
+  if (snapshot.sawQuestion) return false;
+  return !snapshot.sawVisibleText && !snapshot.sawToolActivity && !snapshot.sawProxyActivity;
+}
 function makeAutoContinueMessage() {
   return JSON.stringify({
     type: "user",
@@ -7786,7 +8033,7 @@ var ClaudeCodeLanguageModel = class {
     const toolCalls = [];
     const toolCallStreams = /* @__PURE__ */ new Map();
     let gotPartialEvents = false;
-    const result = await new Promise((resolve5, reject) => {
+    const result = await new Promise((resolve6, reject) => {
       const cleanup = () => {
         try {
           if (!proc.killed && proc.exitCode === null) proc.kill();
@@ -7941,7 +8188,7 @@ ${plan}
               ...turnStatsLogPayload(extractTurnStats(msg))
             });
             cleanup();
-            resolve5({
+            resolve6({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -7953,7 +8200,7 @@ ${plan}
       });
       rl.on("close", () => {
         cleanup();
-        resolve5({
+        resolve6({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -8718,6 +8965,10 @@ ${plan}
           let hadReasoningSinceContinue = false;
           let hadToolActivitySinceContinue = false;
           let hadProxyActivitySinceContinue = false;
+          let sawVisibleText = false;
+          let sawReasoning = false;
+          let sawToolActivity = false;
+          let sawProxyActivity = false;
           let lastStopReason = null;
           const autoContinueState = {
             enabled: autoContinueEnabledFor(
@@ -9009,18 +9260,22 @@ ${plan}
           const noteVisibleText = (text) => {
             visibleTextSinceContinue += text;
             lastVisibleTextSinceContinue += text;
+            if (text.length > 0) sawVisibleText = true;
           };
           const resetLastVisibleTextBlock = () => {
             lastVisibleTextSinceContinue = "";
           };
           const noteReasoning = () => {
             hadReasoningSinceContinue = true;
+            sawReasoning = true;
           };
           const noteToolActivity = () => {
             hadToolActivitySinceContinue = true;
+            sawToolActivity = true;
           };
           const noteProxyActivity = () => {
             hadProxyActivitySinceContinue = true;
+            sawProxyActivity = true;
           };
           const resetAutoContinueWindow = () => {
             visibleTextSinceContinue = "";
@@ -9127,6 +9382,29 @@ ${plan}
                 });
               }
             }
+            if (isSilentTurn({
+              enabled: autoContinueState.enabled,
+              compactionMode,
+              sawVisibleText,
+              sawToolActivity,
+              sawProxyActivity,
+              isError: msg.is_error === true || resultFailure !== void 0,
+              aborted: autoContinueState.aborted,
+              sawQuestion: autoContinueState.sawAskUserQuestion
+            })) {
+              log.notice("claude finished the turn without a reply", {
+                sessionKey: sk,
+                stopReason: lastStopReason,
+                hadReasoning: sawReasoning,
+                attempts: autoContinueState.attempts
+              });
+              controller.enqueue({
+                type: "text-delta",
+                id: startTextBlock(),
+                delta: formatSilentTurnNote(sawReasoning)
+              });
+              endTextBlock();
+            }
             controller.enqueue({
               type: "finish",
               finishReason: resultFailure ? { unified: "error", raw: resultFailure } : toFinishReason2("stop"),
@@ -9432,7 +9710,7 @@ ${plan}
                     if (!skip) {
                       toolCallsById.set(tc.id, {
                         id: tc.id,
-                        name: tc.name,
+                        name: mappedName,
                         input: parsedInput
                       });
                       if (!executed) skipResultForIds.add(tc.id);
@@ -9614,7 +9892,7 @@ ${plan}
                       if (!skip) {
                         toolCallsById.set(block2.id, {
                           id: block2.id,
-                          name: block2.name,
+                          name: mappedName,
                           input: parsedInput
                         });
                         if (!executed) skipResultForIds.add(block2.id);
@@ -10202,14 +10480,15 @@ ${plan}
 
 // src/cleanup-stale.ts
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync6,
   realpathSync as realpathSync2,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join9, resolve as resolve4 } from "path";
+import { dirname as dirname6, join as join9, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -10228,7 +10507,7 @@ function userOpencodeJsonPath() {
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
-  if (!existsSync4(cfg)) return false;
+  if (!existsSync3(cfg)) return false;
   try {
     const json = JSON.parse(readFileSync6(cfg, "utf8"));
     const plugins = json.plugin;
@@ -10243,17 +10522,57 @@ function userIntendsToUseUnscoped() {
 function ourLoadedDir() {
   try {
     const filePath = fileURLToPath3(import.meta.url);
-    return realpathSync2(resolve4(filePath, "..", ".."));
+    return realpathSync2(resolve5(filePath, "..", ".."));
+  } catch {
+    return null;
+  }
+}
+function ourVersion(dir) {
+  if (!dir) return null;
+  try {
+    const pkg = JSON.parse(readFileSync6(join9(dir, "package.json"), "utf8"));
+    return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function markerPath() {
+  const stateRoot = process.env.XDG_STATE_HOME ?? join9(homedir7(), ".local", "state");
+  return join9(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+}
+function markerVersion() {
+  try {
+    const marker = JSON.parse(readFileSync6(markerPath(), "utf8"));
+    return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
   }
 }
+function writeMarker(version) {
+  const file = markerPath();
+  try {
+    mkdirSync4(dirname6(file), { recursive: true });
+    writeFileSync5(
+      file,
+      JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
+      "utf8"
+    );
+  } catch (err) {
+    log.warn("cleanup-stale: could not record the sweep marker", {
+      file,
+      error: String(err)
+    });
+  }
+}
 function cleanupStaleUnscopedInstall() {
   if (alreadyRan) return;
   alreadyRan = true;
   if (process.env.OPENCODE_CLAUDE_CODE_PLUGIN_NO_CLEANUP === "1") return;
   if (userIntendsToUseUnscoped()) return;
   const ourDir = ourLoadedDir();
+  const version = ourVersion(ourDir);
+  const forced = process.env.OPENCODE_CLAUDE_CODE_PLUGIN_FORCE_CLEANUP === "1";
+  if (version && !forced && markerVersion() === version) return;
   for (const cacheRoot of candidateCacheRoots()) {
     try {
       cleanupOne(cacheRoot, ourDir);
@@ -10264,11 +10583,12 @@ function cleanupStaleUnscopedInstall() {
       });
     }
   }
+  if (version) writeMarker(version);
 }
 function cleanupOne(cacheRoot, ourDir) {
-  if (!existsSync4(cacheRoot)) return;
+  if (!existsSync3(cacheRoot)) return;
   const stalePath = join9(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
-  if (!existsSync4(stalePath)) return;
+  if (!existsSync3(stalePath)) return;
   let realStalePath = stalePath;
   try {
     realStalePath = realpathSync2(stalePath);
@@ -10276,7 +10596,7 @@ function cleanupOne(cacheRoot, ourDir) {
   }
   if (ourDir && realStalePath === ourDir) return;
   const pkgJsonPath = join9(stalePath, "package.json");
-  if (!existsSync4(pkgJsonPath)) return;
+  if (!existsSync3(pkgJsonPath)) return;
   let pkg = {};
   try {
     pkg = JSON.parse(readFileSync6(pkgJsonPath, "utf8"));
@@ -10296,7 +10616,7 @@ function cleanupOne(cacheRoot, ourDir) {
     return;
   }
   const cachePkgJson = join9(cacheRoot, "package.json");
-  if (!existsSync4(cachePkgJson)) return;
+  if (!existsSync3(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync6(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
@@ -10781,6 +11101,28 @@ function warnIfPlanModeCannotExit(permissionMode) {
     { permissionMode, measuredOn: "claude-code 2.1.258" }
   );
 }
+function applyPermissionPreset(settings, defaultProxyTools) {
+  const resolved = resolvePermissionPreset(settings, defaultProxyTools);
+  if (resolved === null) return null;
+  if (isUnknownPreset(resolved)) {
+    log.warn(
+      "unknown permissionPreset; no preset applied and every permission setting is left exactly as configured",
+      { permissionPreset: resolved.unknown, known: ["read-only"] }
+    );
+    return null;
+  }
+  log.notice(`permission preset "${resolved.preset}" applied`, {
+    permissionMode: resolved.permissionMode,
+    skipPermissions: resolved.skipPermissions,
+    proxyTools: resolved.proxyTools,
+    disallowedTools: resolved.extraDisallowedTools,
+    controlRequestBehavior: resolved.controlRequestBehavior
+  });
+  for (const line of resolved.overridden) {
+    log.notice(`permission preset "${resolved.preset}" overrode ${line}`);
+  }
+  return resolved;
+}
 function createClaudeCode(settings = {}) {
   if (settings.logging) {
     configureLogger({
@@ -10791,10 +11133,11 @@ function createClaudeCode(settings = {}) {
     });
   }
   warnIfAnthropicApiKey(settings.ignoreAnthropicApiKey);
-  warnIfPlanModeCannotExit(settings.permissionMode);
+  const preset = applyPermissionPreset(settings, DEFAULT_PROXY_TOOL_NAMES);
+  warnIfPlanModeCannotExit(preset ? void 0 : settings.permissionMode);
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
   const providerName = settings.providerID ?? settings.name ?? "claude-code";
-  const proxyTools = settings.proxyTools ?? [...DEFAULT_PROXY_TOOL_NAMES];
+  const proxyTools = preset?.proxyTools ?? settings.proxyTools ?? [...DEFAULT_PROXY_TOOL_NAMES];
   const createModel = (modelId) => {
     return new ClaudeCodeLanguageModel(modelId, {
       provider: providerName,
@@ -10807,18 +11150,19 @@ function createClaudeCode(settings = {}) {
       baseCliPath: settings.baseCliPath ?? cliPath,
       accountFailover: settings.accountFailover ?? "ask",
       providerID: settings.providerID,
-      skipPermissions: settings.skipPermissions ?? true,
-      permissionMode: settings.permissionMode,
+      skipPermissions: preset?.skipPermissions ?? settings.skipPermissions ?? true,
+      permissionMode: preset?.permissionMode ?? settings.permissionMode,
+      permissionPreset: preset?.preset,
       mcpConfig: settings.mcpConfig,
       strictMcpConfig: settings.strictMcpConfig,
       bridgeOpencodeMcp: settings.bridgeOpencodeMcp ?? true,
-      controlRequestBehavior: settings.controlRequestBehavior ?? "allow",
-      controlRequestToolBehaviors: settings.controlRequestToolBehaviors,
+      controlRequestBehavior: preset?.controlRequestBehavior ?? settings.controlRequestBehavior ?? "allow",
+      controlRequestToolBehaviors: preset ? void 0 : settings.controlRequestToolBehaviors,
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
       proxyOpencodeTools: settings.proxyOpencodeTools,
       stripContextReminders: settings.stripContextReminders === true,
-      extraDisallowedTools: settings.extraDisallowedTools,
+      extraDisallowedTools: preset?.extraDisallowedTools ?? settings.extraDisallowedTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
       planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
@@ -11142,6 +11486,7 @@ export {
   ClaudeCodeLanguageModel,
   DEFAULT_PROXY_TOOL_NAMES,
   _resetPlanModeWarningForTests,
+  applyPermissionPreset,
   bridgeOpencodeMcp,
   buildAgentRegistry,
   claudeCodeProviders,