@caspian2026/agent-sdk 0.0.2

package/dist/chunk-ctdg0qxh.js

@@ -0,0 +1,1386 @@
+// @bun
+import {
+  getAutoModeDenials,
+  init_autoModeDenials
+} from "./chunk-0paqc2yw.js";
+import {
+  init_SearchBox
+} from "./chunk-p8na2wwp.js";
+import {
+  init_useSearchInput,
+  useSearchInput
+} from "./chunk-d4kwjqjy.js";
+import {
+  detectUnreachableRules,
+  init_shadowedRuleDetection
+} from "./chunk-kr6qfwq0.js";
+import {
+  AddWorkspaceDirectory,
+  init_AddWorkspaceDirectory
+} from "./chunk-vmbfv1y5.js";
+import"./chunk-vawgyev5.js";
+import"./chunk-mg7pbk0r.js";
+import {
+  BashTool,
+  SandboxManager,
+  Select,
+  TextInput,
+  WebFetchTool,
+  applyPermissionUpdate,
+  createPermissionRetryMessage,
+  deletePermissionRule,
+  getAllowRules,
+  getAskRules,
+  getDenyRules,
+  init_AppState,
+  init_BashTool,
+  init_PermissionUpdate,
+  init_TextInput,
+  init_WebFetchTool,
+  init_messages1 as init_messages,
+  init_permissions,
+  init_sandbox_adapter,
+  init_select,
+  init_useTerminalSize,
+  permissionRuleSourceDisplayString,
+  persistPermissionUpdate,
+  useAppState,
+  useSetAppState
+} from "./chunk-vzgkedm9.js";
+import"./chunk-46hdszda.js";
+import"./chunk-hwfknpxv.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-jzthz1bx.js";
+import"./chunk-1gx78081.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-68w91pzt.js";
+import"./chunk-s4cb0bcb.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-nebezy1d.js";
+import"./chunk-wayfjcwt.js";
+import {
+  init_useExitOnCtrlCDWithKeybindings,
+  useExitOnCtrlCDWithKeybindings
+} from "./chunk-kbm69rtz.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-nxgsnh2y.js";
+import {
+  init_useKeybinding
+} from "./chunk-68ffk5qa.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-bmbq6nt1.js";
+import"./chunk-15sfg4bs.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-b0qptb1k.js";
+import"./chunk-m87bhhqv.js";
+import"./chunk-j3zhb8vv.js";
+import"./chunk-b2fd462a.js";
+import"./chunk-c11swzas.js";
+import"./chunk-chsyvavm.js";
+import"./chunk-5rv9c8yd.js";
+import {
+  SOURCES,
+  getRelativeSettingsFilePathForSource,
+  init_constants,
+  init_permissionRuleParser,
+  init_settings1 as init_settings,
+  init_stringUtils,
+  permissionRuleValueFromString,
+  permissionRuleValueToString,
+  plural
+} from "./chunk-tp2jxmcx.js";
+import"./chunk-z19sd3bt.js";
+import"./chunk-1ax1znzj.js";
+import"./chunk-wha6v7za.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-xp61y5ba.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-4cp6193g.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-yvtzznds.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-2f21meep.js";
+import"./chunk-nrtksr2p.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-s3hsqf80.js";
+import"./chunk-yyf72f78.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  Dialog,
+  Newline,
+  Pane,
+  SearchBox,
+  StatusIcon,
+  Tab,
+  Tabs,
+  ThemedBox_default,
+  ThemedText,
+  init_source,
+  init_src,
+  source_default,
+  useKeybinding,
+  useTabHeaderFocus as useTabHeaderFocus2,
+  useTabsWidth,
+  useTerminalFocus,
+  useTerminalSize,
+  use_input_default
+} from "./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x8d2ehd7.js";
+import"./chunk-15m49c67.js";
+import"./chunk-tdbz9gbm.js";
+import"./chunk-0awwmrwr.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-70eey1nh.js";
+import"./chunk-1nk93fqz.js";
+import"./chunk-s8kj6ajy.js";
+import"./chunk-eenq3avg.js";
+import"./chunk-7mqab3z7.js";
+import"./chunk-5z28bqne.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-qajrkk97.js";
+import {
+  init_slowOperations,
+  jsonStringify
+} from "./chunk-phd1qfpc.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-jaaxk89e.js";
+import {
+  getOriginalCwd,
+  init_state
+} from "./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-55raexh7.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-b0kf00ff.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/permissions/rules/PermissionRuleDescription.tsx
+function PermissionRuleDescription({
+  ruleValue
+}) {
+  switch (ruleValue.toolName) {
+    case BashTool.name: {
+      if (ruleValue.ruleContent) {
+        if (ruleValue.ruleContent.endsWith(":*")) {
+          return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: [
+              "Any Bash command starting with",
+              " ",
+              /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+                bold: true,
+                children: ruleValue.ruleContent.slice(0, -2)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this);
+        } else {
+          return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: [
+              "The Bash command ",
+              /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+                bold: true,
+                children: ruleValue.ruleContent
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this);
+        }
+      } else {
+        return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: "Any Bash command"
+        }, undefined, false, undefined, this);
+      }
+    }
+    default: {
+      if (!ruleValue.ruleContent) {
+        return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: [
+            "Any use of the ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              children: ruleValue.toolName
+            }, undefined, false, undefined, this),
+            " tool"
+          ]
+        }, undefined, true, undefined, this);
+      } else {
+        return null;
+      }
+    }
+  }
+}
+var jsx_dev_runtime;
+var init_PermissionRuleDescription = __esm(() => {
+  init_src();
+  init_BashTool();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/components/permissions/rules/AddPermissionRules.tsx
+function optionForPermissionSaveDestination(saveDestination) {
+  switch (saveDestination) {
+    case "localSettings":
+      return {
+        label: "Project settings (local)",
+        description: `Saved in ${getRelativeSettingsFilePathForSource("localSettings")}`,
+        value: saveDestination
+      };
+    case "projectSettings":
+      return {
+        label: "Project settings",
+        description: `Checked in at ${getRelativeSettingsFilePathForSource("projectSettings")}`,
+        value: saveDestination
+      };
+    case "userSettings":
+      return {
+        label: "User settings",
+        description: `Saved in at ~/.claude/settings.json`,
+        value: saveDestination
+      };
+  }
+}
+function AddPermissionRules({
+  onAddRules,
+  onCancel,
+  ruleValues,
+  ruleBehavior,
+  initialContext,
+  setToolPermissionContext
+}) {
+  const allOptions = SOURCES.map(optionForPermissionSaveDestination);
+  const onSelect = import_react.useCallback((selectedValue) => {
+    if (selectedValue === "cancel") {
+      onCancel();
+      return;
+    } else if (SOURCES.includes(selectedValue)) {
+      const destination = selectedValue;
+      const updatedContext = applyPermissionUpdate(initialContext, {
+        type: "addRules",
+        rules: ruleValues,
+        behavior: ruleBehavior,
+        destination
+      });
+      persistPermissionUpdate({
+        type: "addRules",
+        rules: ruleValues,
+        behavior: ruleBehavior,
+        destination
+      });
+      setToolPermissionContext(updatedContext);
+      const rules = ruleValues.map((ruleValue) => ({
+        ruleValue,
+        ruleBehavior,
+        source: destination
+      }));
+      const sandboxAutoAllowEnabled = SandboxManager.isSandboxingEnabled() && SandboxManager.isAutoAllowBashIfSandboxedEnabled();
+      const allUnreachable = detectUnreachableRules(updatedContext, {
+        sandboxAutoAllowEnabled
+      });
+      const newUnreachable = allUnreachable.filter((u) => ruleValues.some((rv) => rv.toolName === u.rule.ruleValue.toolName && rv.ruleContent === u.rule.ruleValue.ruleContent));
+      onAddRules(rules, newUnreachable.length > 0 ? newUnreachable : undefined);
+    }
+  }, [
+    onAddRules,
+    onCancel,
+    ruleValues,
+    ruleBehavior,
+    initialContext,
+    setToolPermissionContext
+  ]);
+  const title = `Add ${ruleBehavior} permission ${plural(ruleValues.length, "rule")}`;
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Dialog, {
+    title,
+    onCancel,
+    color: "permission",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        paddingX: 2,
+        children: ruleValues.map((ruleValue) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+              bold: true,
+              children: permissionRuleValueToString(ruleValue)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(PermissionRuleDescription, {
+              ruleValue
+            }, undefined, false, undefined, this)
+          ]
+        }, permissionRuleValueToString(ruleValue), true, undefined, this))
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        marginY: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+            children: ruleValues.length === 1 ? "Where should this rule be saved?" : "Where should these rules be saved?"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Select, {
+            options: allOptions,
+            onChange: onSelect
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+var import_react, jsx_dev_runtime2;
+var init_AddPermissionRules = __esm(() => {
+  init_select();
+  init_src();
+  init_PermissionUpdate();
+  init_permissionRuleParser();
+  init_shadowedRuleDetection();
+  init_sandbox_adapter();
+  init_constants();
+  init_settings();
+  init_stringUtils();
+  init_PermissionRuleDescription();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/components/permissions/rules/PermissionRuleInput.tsx
+function PermissionRuleInput({
+  onCancel,
+  onSubmit,
+  ruleBehavior
+}) {
+  const [inputValue, setInputValue] = import_react2.useState("");
+  const [cursorOffset, setCursorOffset] = import_react2.useState(0);
+  const exitState = useExitOnCtrlCDWithKeybindings();
+  useKeybinding("confirm:no", onCancel, { context: "Settings" });
+  const { columns } = useTerminalSize();
+  const textInputColumns = columns - 6;
+  const handleSubmit = (value) => {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length === 0) {
+      return;
+    }
+    const ruleValue = permissionRuleValueFromString(trimmedValue);
+    onSubmit(ruleValue, ruleBehavior);
+  };
+  return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(jsx_dev_runtime3.Fragment, {
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        gap: 1,
+        borderStyle: "round",
+        paddingLeft: 1,
+        paddingRight: 1,
+        borderColor: "permission",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+            bold: true,
+            color: "permission",
+            children: [
+              "Add ",
+              ruleBehavior,
+              " permission rule"
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedBox_default, {
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+                children: [
+                  "Permission rules are a tool name, optionally followed by a specifier in parentheses.",
+                  /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Newline, {}, undefined, false, undefined, this),
+                  "e.g.,",
+                  " ",
+                  /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+                    bold: true,
+                    children: permissionRuleValueToString({ toolName: WebFetchTool.name })
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+                    bold: false,
+                    children: " or "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+                    bold: true,
+                    children: permissionRuleValueToString({
+                      toolName: BashTool.name,
+                      ruleContent: "ls:*"
+                    })
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedBox_default, {
+                borderDimColor: true,
+                borderStyle: "round",
+                marginY: 1,
+                paddingLeft: 1,
+                children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(TextInput, {
+                  showCursor: true,
+                  value: inputValue,
+                  onChange: setInputValue,
+                  onSubmit: handleSubmit,
+                  placeholder: `Enter permission rule${figures_default.ellipsis}`,
+                  columns: textInputColumns,
+                  cursorOffset,
+                  onChangeCursorOffset: setCursorOffset
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedBox_default, {
+        marginLeft: 3,
+        children: exitState.pending ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: [
+            "Press ",
+            exitState.keyName,
+            " again to exit"
+          ]
+        }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: "Enter to submit \xB7 Esc to cancel"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+var import_react2, jsx_dev_runtime3;
+var init_PermissionRuleInput = __esm(() => {
+  init_figures();
+  init_TextInput();
+  init_useExitOnCtrlCDWithKeybindings();
+  init_useTerminalSize();
+  init_src();
+  init_useKeybinding();
+  init_BashTool();
+  init_WebFetchTool();
+  init_permissionRuleParser();
+  import_react2 = __toESM(require_react(), 1);
+  jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/components/permissions/rules/RecentDenialsTab.tsx
+function RecentDenialsTab({
+  onHeaderFocusChange,
+  onStateChange
+}) {
+  const { headerFocused, focusHeader } = useTabHeaderFocus();
+  import_react3.useEffect(() => {
+    onHeaderFocusChange?.(headerFocused);
+  }, [headerFocused, onHeaderFocusChange]);
+  const [denials] = import_react3.useState(() => getAutoModeDenials());
+  const [approved, setApproved] = import_react3.useState(() => new Set);
+  const [retry, setRetry] = import_react3.useState(() => new Set);
+  const [focusedIdx, setFocusedIdx] = import_react3.useState(0);
+  import_react3.useEffect(() => {
+    onStateChange({ approved, retry, denials });
+  }, [approved, retry, denials, onStateChange]);
+  const handleSelect = import_react3.useCallback((value) => {
+    const idx = Number(value);
+    setApproved((prev) => {
+      const next = new Set(prev);
+      if (next.has(idx))
+        next.delete(idx);
+      else
+        next.add(idx);
+      return next;
+    });
+  }, []);
+  const handleFocus = import_react3.useCallback((value) => {
+    setFocusedIdx(Number(value));
+  }, []);
+  use_input_default((input, _key) => {
+    if (input === "r") {
+      setRetry((prev) => {
+        const next = new Set(prev);
+        if (next.has(focusedIdx))
+          next.delete(focusedIdx);
+        else
+          next.add(focusedIdx);
+        return next;
+      });
+      setApproved((prev) => {
+        if (prev.has(focusedIdx))
+          return prev;
+        const next = new Set(prev);
+        next.add(focusedIdx);
+        return next;
+      });
+    }
+  }, { isActive: denials.length > 0 });
+  if (denials.length === 0) {
+    return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: "No recent denials. Commands denied by the auto mode classifier will appear here."
+    }, undefined, false, undefined, this);
+  }
+  const options = denials.map((d, idx) => {
+    const isApproved = approved.has(idx);
+    const suffix = retry.has(idx) ? " (retry)" : "";
+    return {
+      label: /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ThemedText, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(StatusIcon, {
+            status: isApproved ? "success" : "error",
+            withSpace: true
+          }, undefined, false, undefined, this),
+          d.display,
+          /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: suffix
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      value: String(idx)
+    };
+  });
+  return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ThemedText, {
+        children: "Commands recently denied by the auto mode classifier."
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ThemedBox_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Select, {
+          options,
+          onChange: handleSelect,
+          onFocus: handleFocus,
+          visibleOptionCount: Math.min(10, options.length),
+          isDisabled: headerFocused,
+          onUpFromFirstItem: focusHeader
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+var import_react3, jsx_dev_runtime4;
+var init_RecentDenialsTab = __esm(() => {
+  init_src();
+  init_autoModeDenials();
+  init_select();
+  init_src();
+  import_react3 = __toESM(require_react(), 1);
+  jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/components/permissions/rules/RemoveWorkspaceDirectory.tsx
+function RemoveWorkspaceDirectory({
+  directoryPath,
+  onRemove,
+  onCancel,
+  permissionContext,
+  setPermissionContext
+}) {
+  const handleRemove = import_react4.useCallback(() => {
+    const updatedContext = applyPermissionUpdate(permissionContext, {
+      type: "removeDirectories",
+      directories: [directoryPath],
+      destination: "session"
+    });
+    setPermissionContext(updatedContext);
+    onRemove();
+  }, [directoryPath, permissionContext, setPermissionContext, onRemove]);
+  const handleSelect = import_react4.useCallback((value) => {
+    if (value === "yes") {
+      handleRemove();
+    } else {
+      onCancel();
+    }
+  }, [handleRemove, onCancel]);
+  return /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Dialog, {
+    title: "Remove directory from workspace?",
+    onCancel,
+    color: "error",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(ThemedBox_default, {
+        marginX: 2,
+        flexDirection: "column",
+        children: /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(ThemedText, {
+          bold: true,
+          children: directoryPath
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(ThemedText, {
+        children: "Claude Code will no longer have access to files in this directory."
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Select, {
+        onChange: handleSelect,
+        onCancel,
+        options: [
+          { label: "Yes", value: "yes" },
+          { label: "No", value: "no" }
+        ]
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+var import_react4, jsx_dev_runtime5;
+var init_RemoveWorkspaceDirectory = __esm(() => {
+  init_select();
+  init_src();
+  init_PermissionUpdate();
+  init_src();
+  import_react4 = __toESM(require_react(), 1);
+  jsx_dev_runtime5 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/components/permissions/rules/WorkspaceTab.tsx
+function WorkspaceTab({
+  onExit,
+  toolPermissionContext,
+  onRequestAddDirectory,
+  onRequestRemoveDirectory,
+  onHeaderFocusChange
+}) {
+  const { headerFocused, focusHeader } = useTabHeaderFocus();
+  import_react5.useEffect(() => {
+    onHeaderFocusChange?.(headerFocused);
+  }, [headerFocused, onHeaderFocusChange]);
+  const additionalDirectories = React.useMemo(() => {
+    return Array.from(toolPermissionContext.additionalWorkingDirectories.keys()).map((path) => ({
+      path,
+      isCurrent: false,
+      isDeletable: true
+    }));
+  }, [toolPermissionContext.additionalWorkingDirectories]);
+  const handleDirectorySelect = import_react5.useCallback((selectedValue) => {
+    if (selectedValue === "add-directory") {
+      onRequestAddDirectory();
+      return;
+    }
+    const directory = additionalDirectories.find((d) => d.path === selectedValue);
+    if (directory && directory.isDeletable) {
+      onRequestRemoveDirectory(directory.path);
+    }
+  }, [additionalDirectories, onRequestAddDirectory, onRequestRemoveDirectory]);
+  const handleCancel = import_react5.useCallback(() => onExit("Workspace dialog dismissed", { display: "system" }), [onExit]);
+  const options = React.useMemo(() => {
+    const opts = additionalDirectories.map((dir) => ({
+      label: dir.path,
+      value: dir.path
+    }));
+    opts.push({
+      label: `Add directory${figures_default.ellipsis}`,
+      value: "add-directory"
+    });
+    return opts;
+  }, [additionalDirectories]);
+  return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    marginBottom: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ThemedBox_default, {
+        flexDirection: "row",
+        marginTop: 1,
+        marginLeft: 2,
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ThemedText, {
+            children: `-  ${getOriginalCwd()}`
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: "(Original working directory)"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Select, {
+        options,
+        onChange: handleDirectorySelect,
+        onCancel: handleCancel,
+        visibleOptionCount: Math.min(10, options.length),
+        onUpFromFirstItem: focusHeader,
+        isDisabled: headerFocused
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+var React, import_react5, jsx_dev_runtime6;
+var init_WorkspaceTab = __esm(() => {
+  init_figures();
+  init_state();
+  init_select();
+  init_src();
+  React = __toESM(require_react(), 1);
+  import_react5 = __toESM(require_react(), 1);
+  jsx_dev_runtime6 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/components/permissions/rules/PermissionRuleList.tsx
+function RuleSourceText({ rule }) {
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+    dimColor: true,
+    children: `From ${permissionRuleSourceDisplayString(rule.source)}`
+  }, undefined, false, undefined, this);
+}
+function getRuleBehaviorLabel(ruleBehavior) {
+  switch (ruleBehavior) {
+    case "allow":
+      return "allowed";
+    case "deny":
+      return "denied";
+    case "ask":
+      return "ask";
+  }
+}
+function RuleDetails({
+  rule,
+  onDelete,
+  onCancel
+}) {
+  const exitState = useExitOnCtrlCDWithKeybindings();
+  useKeybinding("confirm:no", onCancel, { context: "Confirmation" });
+  const ruleDescription = /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    marginX: 2,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+        bold: true,
+        children: permissionRuleValueToString(rule.ruleValue)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(PermissionRuleDescription, {
+        ruleValue: rule.ruleValue
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(RuleSourceText, {
+        rule
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+  const footer = /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+    marginLeft: 3,
+    children: exitState.pending ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: [
+        "Press ",
+        exitState.keyName,
+        " again to exit"
+      ]
+    }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: "Esc to cancel"
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+  if (rule.source === "policySettings") {
+    return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+          flexDirection: "column",
+          gap: 1,
+          borderStyle: "round",
+          paddingLeft: 1,
+          paddingRight: 1,
+          borderColor: "permission",
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+              bold: true,
+              color: "permission",
+              children: "Rule details"
+            }, undefined, false, undefined, this),
+            ruleDescription,
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+              italic: true,
+              children: [
+                "This rule is configured by managed settings and cannot be modified.",
+                `
+`,
+                "Contact your system administrator for more information."
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        footer
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        gap: 1,
+        borderStyle: "round",
+        paddingLeft: 1,
+        paddingRight: 1,
+        borderColor: "error",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+            bold: true,
+            color: "error",
+            children: [
+              "Delete ",
+              getRuleBehaviorLabel(rule.ruleBehavior),
+              " tool?"
+            ]
+          }, undefined, true, undefined, this),
+          ruleDescription,
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+            children: "Are you sure you want to delete this permission rule?"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Select, {
+            onChange: (_) => _ === "yes" ? onDelete() : onCancel(),
+            onCancel,
+            options: [
+              { label: "Yes", value: "yes" },
+              { label: "No", value: "no" }
+            ]
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      footer
+    ]
+  }, undefined, true, undefined, this);
+}
+function RulesTabContent(props) {
+  const {
+    options,
+    searchQuery,
+    isSearchMode,
+    isFocused,
+    onSelect,
+    onCancel,
+    lastFocusedRuleKey,
+    cursorOffset,
+    onHeaderFocusChange
+  } = props;
+  const tabWidth = useTabsWidth();
+  const { headerFocused, focusHeader, blurHeader } = useTabHeaderFocus2();
+  import_react6.useEffect(() => {
+    if (isSearchMode && headerFocused)
+      blurHeader();
+  }, [isSearchMode, headerFocused, blurHeader]);
+  import_react6.useEffect(() => {
+    onHeaderFocusChange?.(headerFocused);
+  }, [headerFocused, onHeaderFocusChange]);
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+        marginBottom: 1,
+        flexDirection: "column",
+        children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(SearchBox, {
+          query: searchQuery,
+          isFocused: isSearchMode && !headerFocused,
+          isTerminalFocused: isFocused,
+          width: tabWidth,
+          cursorOffset
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Select, {
+        options,
+        onChange: onSelect,
+        onCancel,
+        visibleOptionCount: Math.min(10, options.length),
+        isDisabled: isSearchMode || headerFocused,
+        defaultFocusValue: lastFocusedRuleKey,
+        onUpFromFirstItem: focusHeader
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function PermissionRulesTab({
+  tab,
+  getRulesOptions,
+  handleToolSelect,
+  ...rulesProps
+}) {
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    flexShrink: tab === "allow" ? 0 : undefined,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+        children: {
+          allow: "Claude Code won't ask before using allowed tools.",
+          ask: "Claude Code will always ask for confirmation before using these tools.",
+          deny: "Claude Code will always reject requests to use denied tools."
+        }[tab]
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(RulesTabContent, {
+        options: getRulesOptions(tab, rulesProps.searchQuery).options,
+        onSelect: (v) => handleToolSelect(v, tab),
+        ...rulesProps
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function PermissionRuleList({
+  onExit,
+  initialTab,
+  onRetryDenials
+}) {
+  const hasDenials = getAutoModeDenials().length > 0;
+  const defaultTab = initialTab ?? (hasDenials ? "recent" : "allow");
+  const [changes, setChanges] = import_react6.useState([]);
+  const toolPermissionContext = useAppState((s) => s.toolPermissionContext);
+  const setAppState = useSetAppState();
+  const isTerminalFocused = useTerminalFocus();
+  const denialStateRef = import_react6.useRef({ approved: new Set, retry: new Set, denials: [] });
+  const handleDenialStateChange = import_react6.useCallback((s) => {
+    denialStateRef.current = s;
+  }, []);
+  const [selectedRule, setSelectedRule] = import_react6.useState();
+  const [lastFocusedRuleKey, setLastFocusedRuleKey] = import_react6.useState();
+  const [addingRuleToTab, setAddingRuleToTab] = import_react6.useState(null);
+  const [validatedRule, setValidatedRule] = import_react6.useState(null);
+  const [isAddingWorkspaceDirectory, setIsAddingWorkspaceDirectory] = import_react6.useState(false);
+  const [removingDirectory, setRemovingDirectory] = import_react6.useState(null);
+  const [isSearchMode, setIsSearchMode] = import_react6.useState(false);
+  const [headerFocused, setHeaderFocused] = import_react6.useState(true);
+  const handleHeaderFocusChange = import_react6.useCallback((focused) => {
+    setHeaderFocused(focused);
+  }, []);
+  const allowRulesByKey = import_react6.useMemo(() => {
+    const map = new Map;
+    getAllowRules(toolPermissionContext).forEach((rule) => {
+      map.set(jsonStringify(rule), rule);
+    });
+    return map;
+  }, [toolPermissionContext]);
+  const denyRulesByKey = import_react6.useMemo(() => {
+    const map = new Map;
+    getDenyRules(toolPermissionContext).forEach((rule) => {
+      map.set(jsonStringify(rule), rule);
+    });
+    return map;
+  }, [toolPermissionContext]);
+  const askRulesByKey = import_react6.useMemo(() => {
+    const map = new Map;
+    getAskRules(toolPermissionContext).forEach((rule) => {
+      map.set(jsonStringify(rule), rule);
+    });
+    return map;
+  }, [toolPermissionContext]);
+  const getRulesOptions = import_react6.useCallback((tab, query = "") => {
+    const rulesByKey = (() => {
+      switch (tab) {
+        case "allow":
+          return allowRulesByKey;
+        case "deny":
+          return denyRulesByKey;
+        case "ask":
+          return askRulesByKey;
+        case "workspace":
+        case "recent":
+          return new Map;
+      }
+    })();
+    const options = [];
+    if (tab !== "workspace" && tab !== "recent" && !query) {
+      options.push({
+        label: `Add a new rule${figures_default.ellipsis}`,
+        value: "add-new-rule"
+      });
+    }
+    const sortedRuleKeys = Array.from(rulesByKey.keys()).sort((a, b) => {
+      const ruleA = rulesByKey.get(a);
+      const ruleB = rulesByKey.get(b);
+      if (ruleA && ruleB) {
+        const ruleAString = permissionRuleValueToString(ruleA.ruleValue).toLowerCase();
+        const ruleBString = permissionRuleValueToString(ruleB.ruleValue).toLowerCase();
+        return ruleAString.localeCompare(ruleBString);
+      }
+      return 0;
+    });
+    const lowerQuery = query.toLowerCase();
+    for (const ruleKey of sortedRuleKeys) {
+      const rule = rulesByKey.get(ruleKey);
+      if (rule) {
+        const ruleString = permissionRuleValueToString(rule.ruleValue);
+        if (query && !ruleString.toLowerCase().includes(lowerQuery)) {
+          continue;
+        }
+        options.push({
+          label: ruleString,
+          value: ruleKey
+        });
+      }
+    }
+    return { options, rulesByKey };
+  }, [allowRulesByKey, denyRulesByKey, askRulesByKey]);
+  const exitState = useExitOnCtrlCDWithKeybindings();
+  const isSearchModeActive = !selectedRule && !addingRuleToTab && !validatedRule && !isAddingWorkspaceDirectory && !removingDirectory;
+  const {
+    query: searchQuery,
+    setQuery: setSearchQuery,
+    cursorOffset: searchCursorOffset
+  } = useSearchInput({
+    isActive: isSearchModeActive && isSearchMode,
+    onExit: () => {
+      setIsSearchMode(false);
+    }
+  });
+  const handleKeyDown = import_react6.useCallback((e) => {
+    if (!isSearchModeActive)
+      return;
+    if (isSearchMode)
+      return;
+    if (e.ctrl || e.meta)
+      return;
+    if (e.key === "/") {
+      e.preventDefault();
+      setIsSearchMode(true);
+      setSearchQuery("");
+    } else if (e.key.length === 1 && e.key !== "j" && e.key !== "k" && e.key !== "m" && e.key !== "i" && e.key !== "r" && e.key !== " ") {
+      e.preventDefault();
+      setIsSearchMode(true);
+      setSearchQuery(e.key);
+    }
+  }, [isSearchModeActive, isSearchMode, setSearchQuery]);
+  const handleToolSelect = import_react6.useCallback((selectedValue, tab) => {
+    const { rulesByKey } = getRulesOptions(tab);
+    if (selectedValue === "add-new-rule") {
+      setAddingRuleToTab(tab);
+      return;
+    } else {
+      setSelectedRule(rulesByKey.get(selectedValue));
+      return;
+    }
+  }, [getRulesOptions]);
+  const handleRuleInputCancel = import_react6.useCallback(() => {
+    setAddingRuleToTab(null);
+  }, []);
+  const handleRuleInputSubmit = import_react6.useCallback((ruleValue, ruleBehavior) => {
+    setValidatedRule({ ruleValue, ruleBehavior });
+    setAddingRuleToTab(null);
+  }, []);
+  const handleAddRulesSuccess = import_react6.useCallback((rules, unreachable) => {
+    setValidatedRule(null);
+    for (const rule of rules) {
+      setChanges((prev) => [
+        ...prev,
+        `Added ${rule.ruleBehavior} rule ${source_default.bold(permissionRuleValueToString(rule.ruleValue))}`
+      ]);
+    }
+    if (unreachable && unreachable.length > 0) {
+      for (const u of unreachable) {
+        const severity = u.shadowType === "deny" ? "blocked" : "shadowed";
+        setChanges((prev) => [
+          ...prev,
+          source_default.yellow(`${figures_default.warning} Warning: ${permissionRuleValueToString(u.rule.ruleValue)} is ${severity}`),
+          source_default.dim(`  ${u.reason}`),
+          source_default.dim(`  Fix: ${u.fix}`)
+        ]);
+      }
+    }
+  }, []);
+  const handleAddRuleCancel = import_react6.useCallback(() => {
+    setValidatedRule(null);
+  }, []);
+  const handleRequestAddDirectory = import_react6.useCallback(() => setIsAddingWorkspaceDirectory(true), []);
+  const handleRequestRemoveDirectory = import_react6.useCallback((path) => setRemovingDirectory(path), []);
+  const handleRulesCancel = import_react6.useCallback(() => {
+    const s = denialStateRef.current;
+    const denialsFor = (set) => Array.from(set).map((idx) => s.denials[idx]).filter((d) => d !== undefined);
+    const retryDenials = denialsFor(s.retry);
+    if (retryDenials.length > 0) {
+      const commands = retryDenials.map((d) => d.display);
+      onRetryDenials?.(commands);
+      onExit(undefined, {
+        shouldQuery: true,
+        metaMessages: [
+          `Permission granted for: ${commands.join(", ")}. You may now retry ${commands.length === 1 ? "this command" : "these commands"} if you would like.`
+        ]
+      });
+      return;
+    }
+    const approvedDenials = denialsFor(s.approved);
+    if (approvedDenials.length > 0 || changes.length > 0) {
+      const approvedMsg = approvedDenials.length > 0 ? [
+        `Approved ${approvedDenials.map((d) => source_default.bold(d.display)).join(", ")}`
+      ] : [];
+      onExit([...approvedMsg, ...changes].join(`
+`));
+    } else {
+      onExit("Permissions dialog dismissed", {
+        display: "system"
+      });
+    }
+  }, [changes, onExit, onRetryDenials]);
+  useKeybinding("confirm:no", handleRulesCancel, {
+    context: "Settings",
+    isActive: isSearchModeActive && !isSearchMode
+  });
+  const handleDeleteRule = () => {
+    if (!selectedRule)
+      return;
+    const { options } = getRulesOptions(selectedRule.ruleBehavior);
+    const selectedKey = jsonStringify(selectedRule);
+    const ruleKeys = options.filter((opt) => opt.value !== "add-new-rule").map((opt) => opt.value);
+    const currentIndex = ruleKeys.indexOf(selectedKey);
+    let nextFocusKey;
+    if (currentIndex !== -1) {
+      if (currentIndex < ruleKeys.length - 1) {
+        nextFocusKey = ruleKeys[currentIndex + 1];
+      } else if (currentIndex > 0) {
+        nextFocusKey = ruleKeys[currentIndex - 1];
+      }
+    }
+    setLastFocusedRuleKey(nextFocusKey);
+    deletePermissionRule({
+      rule: selectedRule,
+      initialContext: toolPermissionContext,
+      setToolPermissionContext(toolPermissionContext2) {
+        setAppState((prev) => ({
+          ...prev,
+          toolPermissionContext: toolPermissionContext2
+        }));
+      }
+    });
+    setChanges((prev) => [
+      ...prev,
+      `Deleted ${selectedRule.ruleBehavior} rule ${source_default.bold(permissionRuleValueToString(selectedRule.ruleValue))}`
+    ]);
+    setSelectedRule(undefined);
+  };
+  if (selectedRule) {
+    return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(RuleDetails, {
+      rule: selectedRule,
+      onDelete: handleDeleteRule,
+      onCancel: () => setSelectedRule(undefined)
+    }, undefined, false, undefined, this);
+  }
+  if (addingRuleToTab && addingRuleToTab !== "workspace" && addingRuleToTab !== "recent") {
+    return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(PermissionRuleInput, {
+      onCancel: handleRuleInputCancel,
+      onSubmit: handleRuleInputSubmit,
+      ruleBehavior: addingRuleToTab
+    }, undefined, false, undefined, this);
+  }
+  if (validatedRule) {
+    return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(AddPermissionRules, {
+      onAddRules: handleAddRulesSuccess,
+      onCancel: handleAddRuleCancel,
+      ruleValues: [validatedRule.ruleValue],
+      ruleBehavior: validatedRule.ruleBehavior,
+      initialContext: toolPermissionContext,
+      setToolPermissionContext: (toolPermissionContext2) => {
+        setAppState((prev) => ({
+          ...prev,
+          toolPermissionContext: toolPermissionContext2
+        }));
+      }
+    }, undefined, false, undefined, this);
+  }
+  if (isAddingWorkspaceDirectory) {
+    return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(AddWorkspaceDirectory, {
+      onAddDirectory: (path, remember) => {
+        const destination = remember ? "localSettings" : "session";
+        const permissionUpdate = {
+          type: "addDirectories",
+          directories: [path],
+          destination
+        };
+        const updatedContext = applyPermissionUpdate(toolPermissionContext, permissionUpdate);
+        setAppState((prev) => ({
+          ...prev,
+          toolPermissionContext: updatedContext
+        }));
+        if (remember) {
+          persistPermissionUpdate(permissionUpdate);
+        }
+        setChanges((prev) => [
+          ...prev,
+          `Added directory ${source_default.bold(path)} to workspace${remember ? " and saved to local settings" : " for this session"}`
+        ]);
+        setIsAddingWorkspaceDirectory(false);
+      },
+      onCancel: () => setIsAddingWorkspaceDirectory(false),
+      permissionContext: toolPermissionContext
+    }, undefined, false, undefined, this);
+  }
+  if (removingDirectory) {
+    return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(RemoveWorkspaceDirectory, {
+      directoryPath: removingDirectory,
+      onRemove: () => {
+        setChanges((prev) => [
+          ...prev,
+          `Removed directory ${source_default.bold(removingDirectory)} from workspace`
+        ]);
+        setRemovingDirectory(null);
+      },
+      onCancel: () => setRemovingDirectory(null),
+      permissionContext: toolPermissionContext,
+      setPermissionContext: (toolPermissionContext2) => {
+        setAppState((prev) => ({
+          ...prev,
+          toolPermissionContext: toolPermissionContext2
+        }));
+      }
+    }, undefined, false, undefined, this);
+  }
+  const sharedRulesProps = {
+    searchQuery,
+    isSearchMode,
+    isFocused: isTerminalFocused,
+    onCancel: handleRulesCancel,
+    lastFocusedRuleKey,
+    cursorOffset: searchCursorOffset,
+    getRulesOptions,
+    handleToolSelect,
+    onHeaderFocusChange: handleHeaderFocusChange
+  };
+  const isHidden = !!selectedRule || !!addingRuleToTab || !!validatedRule || isAddingWorkspaceDirectory || !!removingDirectory;
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    onKeyDown: handleKeyDown,
+    children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Pane, {
+      color: "permission",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Tabs, {
+          title: "Permissions:",
+          color: "permission",
+          defaultTab,
+          hidden: isHidden,
+          initialHeaderFocused: !hasDenials,
+          navFromContent: !isSearchMode,
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Tab, {
+              id: "recent",
+              title: "Recently denied",
+              children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(RecentDenialsTab, {
+                onHeaderFocusChange: handleHeaderFocusChange,
+                onStateChange: handleDenialStateChange
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Tab, {
+              id: "allow",
+              title: "Allow",
+              children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(PermissionRulesTab, {
+                tab: "allow",
+                ...sharedRulesProps
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Tab, {
+              id: "ask",
+              title: "Ask",
+              children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(PermissionRulesTab, {
+                tab: "ask",
+                ...sharedRulesProps
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Tab, {
+              id: "deny",
+              title: "Deny",
+              children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(PermissionRulesTab, {
+                tab: "deny",
+                ...sharedRulesProps
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Tab, {
+              id: "workspace",
+              title: "Workspace",
+              children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+                flexDirection: "column",
+                children: [
+                  /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+                    children: "Claude Code can read files in the workspace, and make edits when auto-accept edits is on."
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(WorkspaceTab, {
+                    onExit,
+                    toolPermissionContext,
+                    onRequestAddDirectory: handleRequestAddDirectory,
+                    onRequestRemoveDirectory: handleRequestRemoveDirectory,
+                    onHeaderFocusChange: handleHeaderFocusChange
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedBox_default, {
+          marginTop: 1,
+          paddingLeft: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: exitState.pending ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+              children: [
+                "Press ",
+                exitState.keyName,
+                " again to exit"
+              ]
+            }, undefined, true, undefined, this) : headerFocused ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+              children: "\u2190/\u2192 tab switch \xB7 \u2193 return \xB7 Esc cancel"
+            }, undefined, false, undefined, this) : isSearchMode ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+              children: "Type to filter \xB7 Enter/\u2193 select \xB7 \u2191 tabs \xB7 Esc clear"
+            }, undefined, false, undefined, this) : hasDenials && defaultTab === "recent" ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+              children: "Enter approve \xB7 r retry \xB7 \u2191\u2193 navigate \xB7 \u2190/\u2192 switch \xB7 Esc cancel"
+            }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+              children: "\u2191\u2193 navigate \xB7 Enter select \xB7 Type to search \xB7 \u2190/\u2192 switch \xB7 Esc cancel"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+var import_react6, jsx_dev_runtime7;
+var init_PermissionRuleList = __esm(() => {
+  init_source();
+  init_figures();
+  init_AppState();
+  init_PermissionUpdate();
+  init_select();
+  init_useExitOnCtrlCDWithKeybindings();
+  init_useSearchInput();
+  init_src();
+  init_useKeybinding();
+  init_autoModeDenials();
+  init_permissionRuleParser();
+  init_permissions();
+  init_slowOperations();
+  init_src();
+  init_SearchBox();
+  init_AddPermissionRules();
+  init_AddWorkspaceDirectory();
+  init_PermissionRuleDescription();
+  init_PermissionRuleInput();
+  init_RecentDenialsTab();
+  init_RemoveWorkspaceDirectory();
+  init_WorkspaceTab();
+  import_react6 = __toESM(require_react(), 1);
+  jsx_dev_runtime7 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/commands/permissions/permissions.tsx
+var jsx_dev_runtime8, call = async (onDone, context) => {
+  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(PermissionRuleList, {
+    onExit: onDone,
+    onRetryDenials: (commands) => {
+      context.setMessages((prev) => [
+        ...prev,
+        createPermissionRetryMessage(commands)
+      ]);
+    }
+  }, undefined, false, undefined, this);
+};
+var init_permissions2 = __esm(() => {
+  init_PermissionRuleList();
+  init_messages();
+  jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_permissions2();
+
+export {
+  call
+};