opencode-project-panel 0.1.0

package/dist/index.js

@@ -0,0 +1,3975 @@
+// @bun
+// src/bottom-bar.tsx
+import { RGBA as RGBA4 } from "@opentui/core";
+import { useBindings as useBindings4 } from "@opentui/keymap/solid";
+import { writeFileSync as writeFileSync4, existsSync as existsSync2 } from "fs";
+import path4 from "path";
+
+// src/new-file-manager.tsx
+import { RGBA as RGBA2, SyntaxStyle as SyntaxStyle2, parseColor as parseColor2 } from "@opentui/core";
+import { useTerminalDimensions as useTerminalDimensions2 } from "@opentui/solid";
+import { useBindings as useBindings2 } from "@opentui/keymap/solid";
+import { onCleanup } from "solid-js";
+import { readdirSync, readFileSync as readFileSync2, openSync, readSync, closeSync, mkdirSync, writeFileSync as writeFileSync2, renameSync, rmSync, statSync } from "fs";
+import path2 from "path";
+
+// src/file-viewer.tsx
+import { RGBA, SyntaxStyle, parseColor } from "@opentui/core";
+import { useTerminalDimensions } from "@opentui/solid";
+import { useBindings } from "@opentui/keymap/solid";
+import { createSignal, onMount } from "solid-js";
+import { readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { jsxDEV } from "@opentui/solid/jsx-dev-runtime";
+var SYNTAX_STYLE = SyntaxStyle.fromStyles({
+  default: { fg: parseColor("#E6EDF3") },
+  keyword: { fg: parseColor("#FF7B72"), bold: true },
+  string: { fg: parseColor("#A5D6FF") },
+  comment: { fg: parseColor("#8B949E"), italic: true },
+  number: { fg: parseColor("#79C0FF") },
+  function: { fg: parseColor("#D2A8FF") },
+  type: { fg: parseColor("#FFA657") },
+  operator: { fg: parseColor("#FF7B72") },
+  variable: { fg: parseColor("#E6EDF3") },
+  property: { fg: parseColor("#79C0FF") },
+  "punctuation.bracket": { fg: parseColor("#F0F6FC") },
+  "punctuation.delimiter": { fg: parseColor("#C9D1D9") },
+  "markup.heading": { fg: parseColor("#58A6FF"), bold: true },
+  "markup.bold": { fg: parseColor("#F0F6FC"), bold: true },
+  "markup.italic": { fg: parseColor("#F0F6FC"), italic: true },
+  "markup.list": { fg: parseColor("#FF7B72") },
+  "markup.quote": { fg: parseColor("#8B949E"), italic: true },
+  "markup.raw": { fg: parseColor("#A5D6FF"), bg: parseColor("#161B22") },
+  "markup.link": { fg: parseColor("#58A6FF"), underline: true },
+  "markup.link.url": { fg: parseColor("#58A6FF"), underline: true },
+  "diff.plus": { fg: parseColor("#3FB950") },
+  "diff.minus": { fg: parseColor("#F85149") },
+  conceal: { fg: parseColor("#6E7681") }
+});
+var SEARCH_HL_STYLE_ID = SYNTAX_STYLE.registerStyle("search-match", { bg: parseColor("#FF8C00"), fg: parseColor("#000000") });
+var SEARCH_CURRENT_HL_STYLE_ID = SYNTAX_STYLE.registerStyle("search-current", { bg: parseColor("#FFFF00"), fg: parseColor("#000000"), bold: true });
+var EXT_TO_FILETYPE = {
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".json": "json",
+  ".md": "markdown",
+  ".mdx": "markdown",
+  ".css": "css",
+  ".html": "html",
+  ".xml": "xml",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".py": "python",
+  ".rb": "ruby",
+  ".go": "go",
+  ".rs": "rust",
+  ".zig": "zig",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".lua": "lua",
+  ".sql": "sql",
+  ".graphql": "graphql",
+  ".proto": "protobuf",
+  ".tf": "terraform",
+  ".scala": "scala",
+  ".r": "r",
+  ".pl": "perl",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".clj": "clojure",
+  ".nix": "nix"
+};
+var MD_EXT = new Set([".md", ".mdx", ".markdown"]);
+function isMarkdownPath(fp) {
+  return MD_EXT.has(path.extname(fp).toLowerCase());
+}
+var HINT_FG = RGBA.fromInts(180, 180, 180, 255);
+var FG = RGBA.fromInts(255, 255, 255, 255);
+function FileViewer(props) {
+  let codeRef;
+  let markdownRef;
+  let textareaRef;
+  let searchInputRef;
+  let previewScrollBox;
+  let dirtyEl;
+  let matchCountEl;
+  let previewButtonsBox;
+  let editButtonsBox;
+  let searchBox;
+  let bottomBarBox;
+  const dimensions = useTerminalDimensions();
+  const theme = () => props.api.theme.current;
+  const isMarkdown = isMarkdownPath(props.filePath);
+  const filetype = EXT_TO_FILETYPE[path.extname(props.filePath).toLowerCase()] ?? "";
+  const [mode, setMode] = createSignal(props.initialMode ?? "preview");
+  const [focusedId, setFocusedId] = createSignal("content");
+  const [textareaTarget, setTextareaTarget] = createSignal();
+  const [searchInputTarget, setSearchInputTarget] = createSignal();
+  let dirty = false;
+  let originalContent = "";
+  let searchQuery = "";
+  let matches = [];
+  let currentMatch = -1;
+  try {
+    originalContent = readFileSync(props.filePath, "utf-8");
+  } catch {
+    originalContent = "// Error reading file";
+  }
+  const panelWidth = () => Math.min(Math.max(dimensions().width - 2, 60), 116);
+  const panelHeight = () => Math.max(Math.floor(dimensions().height * 0.78) - 2, 22);
+  const refreshMatchCount = () => {
+    if (matches.length === 0) {
+      matchCountEl.content = searchQuery ? "0/0" : "";
+    } else {
+      matchCountEl.content = `${currentMatch + 1}/${matches.length}`;
+    }
+  };
+  function setFocusTarget(id) {
+    setFocusedId(id);
+    if (id === "content") {
+      searchInputRef?.blur();
+      if (mode() === "edit")
+        textareaRef?.focus();
+    } else {
+      if (mode() === "edit")
+        textareaRef?.blur();
+      searchInputRef?.focus();
+    }
+  }
+  function setModeVisible(next) {
+    setMode(next);
+    const isPrev = next === "preview";
+    if (previewScrollBox)
+      previewScrollBox.visible = isPrev;
+    if (textareaRef)
+      textareaRef.visible = !isPrev;
+    if (previewButtonsBox)
+      previewButtonsBox.visible = isPrev;
+    if (editButtonsBox)
+      editButtonsBox.visible = !isPrev;
+    if (searchBox)
+      searchBox.visible = !isPrev;
+    if (bottomBarBox)
+      bottomBarBox.paddingBottom = isPrev ? 1 : 0;
+    if (isPrev) {
+      if (isMarkdown)
+        markdownRef.content = originalContent;
+      else
+        codeRef.content = originalContent;
+    } else {
+      textareaRef.setText(originalContent);
+    }
+    setFocusTarget("content");
+  }
+  const switchMode = setModeVisible;
+  function reload() {
+    try {
+      const content = readFileSync(props.filePath, "utf-8");
+      originalContent = content;
+      if (isMarkdown)
+        markdownRef.content = content;
+      else
+        codeRef.content = content;
+      textareaRef.setText(content);
+    } catch {}
+    dirty = false;
+    dirtyEl.content = "";
+    matches = [];
+    currentMatch = -1;
+    refreshMatchCount();
+  }
+  function save() {
+    try {
+      writeFileSync(props.filePath, textareaRef.plainText, "utf-8");
+      originalContent = textareaRef.plainText;
+    } catch {}
+    dirty = false;
+    dirtyEl.content = "";
+    setModeVisible("preview");
+  }
+  function cancelEdit() {
+    textareaRef.setText(originalContent);
+    dirty = false;
+    dirtyEl.content = "";
+    setModeVisible("preview");
+  }
+  function pageUp() {
+    if (!textareaRef)
+      return;
+    const vp = textareaRef.editorView.getViewport();
+    const cur = textareaRef.logicalCursor.row;
+    textareaRef.gotoLine(Math.max(0, cur - vp.height));
+  }
+  function pageDown() {
+    if (!textareaRef)
+      return;
+    const vp = textareaRef.editorView.getViewport();
+    const cur = textareaRef.logicalCursor.row;
+    textareaRef.gotoLine(cur + vp.height);
+  }
+  function toggleMode() {
+    if (mode() === "preview")
+      switchMode("edit");
+    else
+      cancelEdit();
+  }
+  function offsetExcludingNewlines(text, offset) {
+    let nl = 0;
+    for (let i = 0;i < offset && i < text.length; i++) {
+      if (text[i] === `
+`)
+        nl++;
+    }
+    return offset - nl;
+  }
+  function computeMatches(query) {
+    searchQuery = query;
+    if (!textareaRef)
+      return;
+    textareaRef.clearAllHighlights();
+    if (!query) {
+      matches = [];
+      currentMatch = -1;
+      refreshMatchCount();
+      return;
+    }
+    const found = [];
+    const text = textareaRef.plainText;
+    let pos = 0;
+    while (pos <= text.length) {
+      const idx = text.indexOf(query, pos);
+      if (idx === -1)
+        break;
+      found.push({ start: idx, end: idx + query.length });
+      pos = idx + query.length;
+    }
+    matches = found;
+    currentMatch = matches.length > 0 ? 0 : -1;
+    applyHighlights();
+    refreshMatchCount();
+    scrollToCurrentMatch();
+  }
+  function applyHighlights() {
+    if (!textareaRef || !matches.length)
+      return;
+    const text = textareaRef.plainText;
+    textareaRef.clearAllHighlights();
+    matches.forEach((m, i) => {
+      textareaRef.addHighlightByCharRange({
+        start: offsetExcludingNewlines(text, m.start),
+        end: offsetExcludingNewlines(text, m.end),
+        styleId: i === currentMatch ? SEARCH_CURRENT_HL_STYLE_ID : SEARCH_HL_STYLE_ID,
+        hlRef: i
+      });
+    });
+  }
+  function scrollToCurrentMatch() {
+    const match = matches[currentMatch];
+    if (!textareaRef || !match)
+      return;
+    textareaRef.cursorOffset = match.start;
+  }
+  function nextMatch() {
+    if (matches.length === 0)
+      return;
+    currentMatch = (currentMatch + 1) % matches.length;
+    applyHighlights();
+    refreshMatchCount();
+    scrollToCurrentMatch();
+  }
+  function prevMatch() {
+    if (matches.length === 0)
+      return;
+    currentMatch = (currentMatch - 1 + matches.length) % matches.length;
+    applyHighlights();
+    refreshMatchCount();
+    scrollToCurrentMatch();
+  }
+  useBindings(() => ({
+    priority: 2,
+    enabled: () => focusedId() !== "search",
+    bindings: [
+      { key: "f5", cmd: reload },
+      { key: "ctrl+e", cmd: toggleMode },
+      { key: "ctrl+q", cmd: cancelEdit }
+    ]
+  }));
+  useBindings(() => ({
+    priority: 2,
+    enabled: () => mode() === "edit",
+    bindings: [
+      { key: "ctrl+n", cmd: nextMatch },
+      { key: "ctrl+p", cmd: prevMatch },
+      { key: "f3", cmd: nextMatch },
+      { key: "pageup", cmd: pageUp },
+      { key: "pagedown", cmd: pageDown }
+    ]
+  }));
+  useBindings(() => ({
+    priority: 2,
+    enabled: () => mode() === "preview",
+    bindings: [
+      { key: "home", cmd: () => {
+        if (previewScrollBox)
+          previewScrollBox.scrollTop = 0;
+      } },
+      { key: "end", cmd: () => {
+        if (previewScrollBox)
+          previewScrollBox.scrollTop = previewScrollBox.scrollHeight - previewScrollBox.height;
+      } },
+      { key: "pageup", cmd: () => previewScrollBox?.scrollBy({ y: -(previewScrollBox?.height ?? 0) }) },
+      { key: "pagedown", cmd: () => previewScrollBox?.scrollBy({ y: previewScrollBox?.height ?? 0 }) },
+      { key: "up", cmd: () => previewScrollBox?.scrollBy({ y: -1 }) },
+      { key: "down", cmd: () => previewScrollBox?.scrollBy({ y: 1 }) }
+    ]
+  }));
+  useBindings(() => ({
+    target: textareaTarget,
+    enabled: textareaTarget() !== undefined,
+    priority: 1,
+    bindings: [
+      {
+        key: "return",
+        cmd: () => textareaRef?.newLine()
+      },
+      {
+        key: "home",
+        cmd: () => textareaRef?.gotoLineHome()
+      },
+      {
+        key: "end",
+        cmd: () => textareaRef?.gotoLineEnd()
+      },
+      {
+        key: "ctrl+s",
+        cmd: () => {
+          if (mode() === "edit")
+            save();
+        }
+      },
+      { key: "ctrl+f", cmd: () => setFocusTarget("search") }
+    ]
+  }));
+  useBindings(() => ({
+    target: searchInputTarget,
+    enabled: searchInputTarget() !== undefined,
+    priority: 1,
+    bindings: [
+      {
+        key: "escape",
+        cmd: () => setFocusTarget("content")
+      }
+    ]
+  }));
+  useBindings(() => ({
+    priority: 2,
+    enabled: () => focusedId() !== "search",
+    bindings: [
+      {
+        key: "escape",
+        cmd: () => {
+          if (props.onBack)
+            props.onBack();
+        }
+      }
+    ]
+  }));
+  onMount(() => {
+    if (props.initialMode === "edit") {
+      switchMode("edit");
+    }
+  });
+  return /* @__PURE__ */ jsxDEV("box", {
+    width: panelWidth(),
+    height: panelHeight(),
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV("box", {
+        paddingLeft: 2,
+        paddingRight: 2,
+        flexShrink: 0,
+        border: ["bottom"],
+        borderColor: theme().textMuted,
+        flexDirection: "row",
+        children: [
+          /* @__PURE__ */ jsxDEV("text", {
+            fg: theme().text,
+            children: [
+              "File Path: ",
+              props.filePath
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV("text", {
+            ref: (el) => {
+              dirtyEl = el;
+            },
+            fg: theme().textMuted
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("box", {
+            flexGrow: 1
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("box", {
+            flexDirection: "row",
+            onMouseUp: () => {
+              if (props.onBack)
+                props.onBack();
+            },
+            children: [
+              /* @__PURE__ */ jsxDEV("text", {
+                fg: HINT_FG,
+                children: "[ESC]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV("text", {
+                fg: FG,
+                children: " Close"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV("scrollbox", {
+        ref: (el) => {
+          previewScrollBox = el;
+        },
+        width: "100%",
+        flexGrow: 1,
+        scrollbarOptions: { visible: true },
+        children: [
+          /* @__PURE__ */ jsxDEV("code", {
+            ref: (el) => {
+              codeRef = el;
+              el.content = originalContent;
+              el.filetype = filetype;
+            },
+            visible: !isMarkdown,
+            syntaxStyle: SYNTAX_STYLE,
+            selectable: true,
+            width: "100%",
+            onMouseDown: () => setFocusTarget("content")
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("markdown", {
+            ref: (el) => {
+              markdownRef = el;
+              el.content = originalContent;
+            },
+            visible: isMarkdown,
+            syntaxStyle: SYNTAX_STYLE,
+            conceal: true,
+            fg: theme().text,
+            width: "100%"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV("textarea", {
+        ref: (el) => {
+          textareaRef = el;
+          setTextareaTarget(el);
+          el.setText(originalContent);
+        },
+        visible: false,
+        syntaxStyle: SYNTAX_STYLE,
+        flexGrow: 1,
+        selectable: true,
+        onMouseDown: () => setFocusTarget("content"),
+        onContentChange: () => {
+          if (!dirty) {
+            dirty = true;
+            dirtyEl.content = "*";
+          }
+          if (searchQuery && mode() === "edit")
+            computeMatches(searchQuery);
+        }
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("box", {
+        ref: (el) => {
+          bottomBarBox = el;
+        },
+        flexShrink: 0,
+        flexDirection: "row",
+        paddingLeft: 2,
+        paddingTop: 1,
+        paddingBottom: 1,
+        gap: 2,
+        border: ["top"],
+        borderColor: theme().textMuted,
+        children: /* @__PURE__ */ jsxDEV("box", {
+          flexDirection: "row",
+          gap: 3,
+          flexGrow: 1,
+          children: [
+            /* @__PURE__ */ jsxDEV("box", {
+              ref: (el) => {
+                previewButtonsBox = el;
+              },
+              visible: true,
+              flexDirection: "row",
+              gap: 3,
+              children: [
+                /* @__PURE__ */ jsxDEV("box", {
+                  flexDirection: "row",
+                  gap: 0,
+                  onMouseDown: reload,
+                  children: [
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: HINT_FG,
+                      children: "[F5]"
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: theme().text,
+                      children: " Reload"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this),
+                /* @__PURE__ */ jsxDEV("box", {
+                  flexDirection: "row",
+                  gap: 0,
+                  onMouseDown: () => switchMode("edit"),
+                  children: [
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: HINT_FG,
+                      children: "[Ctrl+E]"
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: theme().text,
+                      children: " Edit"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV("box", {
+              ref: (el) => {
+                editButtonsBox = el;
+              },
+              visible: false,
+              flexDirection: "row",
+              gap: 3,
+              children: [
+                /* @__PURE__ */ jsxDEV("box", {
+                  flexDirection: "row",
+                  gap: 0,
+                  onMouseDown: save,
+                  children: [
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: HINT_FG,
+                      children: "[Ctrl+S]"
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: theme().text,
+                      children: " Save"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this),
+                /* @__PURE__ */ jsxDEV("box", {
+                  flexDirection: "row",
+                  gap: 0,
+                  onMouseDown: cancelEdit,
+                  children: [
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: HINT_FG,
+                      children: "[Ctrl+Q]"
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV("text", {
+                      fg: theme().text,
+                      children: " Cancel"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV("box", {
+              ref: (el) => {
+                searchBox = el;
+              },
+              visible: false,
+              flexDirection: "row",
+              flexGrow: 1,
+              border: ["bottom"],
+              borderColor: theme().textMuted,
+              children: [
+                /* @__PURE__ */ jsxDEV("text", {
+                  fg: HINT_FG,
+                  flexShrink: 0,
+                  children: "[Ctrl+F]"
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("text", {
+                  fg: theme().textMuted,
+                  children: " "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("input", {
+                  ref: (el) => {
+                    searchInputRef = el;
+                    setSearchInputTarget(el);
+                  },
+                  placeholder: "Search...",
+                  flexGrow: 1,
+                  onMouseDown: () => setFocusTarget("search"),
+                  onInput: (value) => computeMatches(value),
+                  onSubmit: () => nextMatch()
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("text", {
+                  fg: theme().textMuted,
+                  children: " "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("text", {
+                  fg: theme().textMuted,
+                  onMouseDown: prevMatch,
+                  children: "\u25C0"
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("text", {
+                  fg: theme().textMuted,
+                  onMouseDown: nextMatch,
+                  children: "\u25B6"
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("text", {
+                  fg: theme().textMuted,
+                  children: " "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("text", {
+                  ref: (el) => {
+                    matchCountEl = el;
+                  },
+                  fg: theme().textMuted
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/new-file-manager.tsx
+import { jsxDEV as jsxDEV2 } from "@opentui/solid/jsx-dev-runtime";
+var currentFileActions = null;
+var focusedPane = "select";
+var isOverlayActive = false;
+var TEXT_EXTENSIONS = new Set([
+  ".txt",
+  ".md",
+  ".mdx",
+  ".markdown",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".jsonc",
+  ".json5",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".xml",
+  ".svg",
+  ".xsl",
+  ".xslt",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".styl",
+  ".html",
+  ".htm",
+  ".xhtml",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".py",
+  ".pyw",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".cxx",
+  ".cc",
+  ".h",
+  ".hpp",
+  ".hxx",
+  ".hh",
+  ".cs",
+  ".fs",
+  ".fsx",
+  ".ex",
+  ".exs",
+  ".erl",
+  ".hrl",
+  ".clj",
+  ".cljs",
+  ".cljc",
+  ".edn",
+  ".scala",
+  ".sbt",
+  ".zig",
+  ".r",
+  ".rda",
+  ".m",
+  ".mm",
+  ".pl",
+  ".pm",
+  ".t",
+  ".lua",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".proto",
+  ".tf",
+  ".tfvars",
+  ".nix",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  ".env",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".log",
+  ".gitignore",
+  ".dockerignore",
+  ".helmignore",
+  ".dockerfile",
+  ".makefile",
+  ".npmrc",
+  ".yarnrc",
+  ".pnpmrc",
+  ".editorconfig",
+  ".prettierrc",
+  ".eslintrc",
+  ".babelrc",
+  ".stylelintrc",
+  ".commitlintrc",
+  ".browserslistrc",
+  ".nvmrc",
+  ".node-version",
+  ".python-version",
+  ".ruby-version"
+]);
+var HINT_FG2 = RGBA2.fromInts(180, 180, 180, 255);
+var FG2 = RGBA2.fromInts(255, 255, 255, 255);
+var KNOWN_TEXT_FILENAMES = new Set([
+  "makefile",
+  "dockerfile",
+  "composefile",
+  "rakefile",
+  "gemfile",
+  "podfile",
+  "cartfile",
+  "readme",
+  "license",
+  "changelog",
+  "contributing",
+  "build",
+  "workspace",
+  "cargo.toml",
+  "package.swift",
+  ".gitattributes",
+  ".gitmodules",
+  ".npmignore",
+  ".dockerignore",
+  "procfile",
+  ".slugignore",
+  "nginx.conf",
+  "httpd.conf"
+]);
+function hasNullByte(filePath) {
+  try {
+    const fd = openSync(filePath, "r");
+    const buf = Buffer.alloc(4096);
+    const bytesRead = readSync(fd, buf, 0, 4096, 0);
+    closeSync(fd);
+    return bytesRead > 0 && buf.subarray(0, bytesRead).includes(0);
+  } catch {
+    return true;
+  }
+}
+function isTextFile(name, fullPath) {
+  const ext = path2.extname(name).toLowerCase();
+  if (TEXT_EXTENSIONS.has(ext))
+    return true;
+  if (KNOWN_TEXT_FILENAMES.has(name.toLowerCase()))
+    return true;
+  if (/^[^.]+$/.test(name) && KNOWN_TEXT_FILENAMES.has(name.toLowerCase()))
+    return true;
+  if (!ext && !KNOWN_TEXT_FILENAMES.has(name.toLowerCase())) {
+    return !hasNullByte(fullPath);
+  }
+  return !hasNullByte(fullPath);
+}
+var SYNTAX_STYLE2 = SyntaxStyle2.fromStyles({
+  default: { fg: parseColor2("#E6EDF3") },
+  keyword: { fg: parseColor2("#FF7B72"), bold: true },
+  string: { fg: parseColor2("#A5D6FF") },
+  comment: { fg: parseColor2("#8B949E"), italic: true },
+  number: { fg: parseColor2("#79C0FF") },
+  function: { fg: parseColor2("#D2A8FF") },
+  type: { fg: parseColor2("#FFA657") },
+  operator: { fg: parseColor2("#FF7B72") },
+  variable: { fg: parseColor2("#E6EDF3") },
+  property: { fg: parseColor2("#79C0FF") },
+  "punctuation.bracket": { fg: parseColor2("#F0F6FC") },
+  "punctuation.delimiter": { fg: parseColor2("#C9D1D9") },
+  "markup.heading": { fg: parseColor2("#58A6FF"), bold: true },
+  "markup.bold": { fg: parseColor2("#F0F6FC"), bold: true },
+  "markup.italic": { fg: parseColor2("#F0F6FC"), italic: true },
+  "markup.list": { fg: parseColor2("#FF7B72") },
+  "markup.quote": { fg: parseColor2("#8B949E"), italic: true },
+  "markup.raw": { fg: parseColor2("#A5D6FF"), bg: parseColor2("#161B22") },
+  "markup.link": { fg: parseColor2("#58A6FF"), underline: true },
+  "markup.link.url": { fg: parseColor2("#58A6FF"), underline: true },
+  "diff.plus": { fg: parseColor2("#3FB950") },
+  "diff.minus": { fg: parseColor2("#F85149") },
+  conceal: { fg: parseColor2("#6E7681") }
+});
+var EXT_TO_FILETYPE2 = {
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".json": "json",
+  ".md": "markdown",
+  ".mdx": "markdown",
+  ".css": "css",
+  ".html": "html",
+  ".xml": "xml",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".py": "python",
+  ".rb": "ruby",
+  ".go": "go",
+  ".rs": "rust",
+  ".zig": "zig",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".lua": "lua",
+  ".sql": "sql",
+  ".graphql": "graphql",
+  ".proto": "protobuf",
+  ".tf": "terraform",
+  ".scala": "scala",
+  ".r": "r",
+  ".pl": "perl",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".clj": "clojure",
+  ".nix": "nix"
+};
+function readDir(dir) {
+  try {
+    const items = readdirSync(dir, { withFileTypes: true });
+    const dirs = items.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, fullPath: path2.join(dir, e.name), isDir: true })).sort((a, b) => a.name.localeCompare(b.name));
+    const files = items.filter((e) => e.isFile()).map((e) => ({ name: e.name, fullPath: path2.join(dir, e.name), isDir: false })).sort((a, b) => a.name.localeCompare(b.name));
+    const isRoot = path2.resolve(dir, "..") === dir;
+    const parent = isRoot ? undefined : { name: "..", fullPath: path2.resolve(dir, ".."), isDir: true };
+    return parent ? [parent, ...dirs, ...files] : [...dirs, ...files];
+  } catch {
+    return [];
+  }
+}
+function toOptions(entries) {
+  return entries.map((e) => ({
+    name: (e.isDir ? "\uD83D\uDCC1 " : "\uD83D\uDCC4 ") + e.name + (e.isDir ? "/" : ""),
+    description: e.isDir ? "directory" : path2.extname(e.name) || "(file)",
+    value: e.fullPath
+  }));
+}
+function describeFile(name) {
+  const ext = path2.extname(name).toLowerCase();
+  if (ext)
+    return ext;
+  const lower = name.toLowerCase();
+  if (KNOWN_TEXT_FILENAMES.has(lower))
+    return lower;
+  return "(file)";
+}
+function NewFileManager(props) {
+  currentFileActions = {
+    create: handleCreate,
+    rename: handleRename,
+    delete: handleDelete,
+    goto: handleGoto,
+    focusFilter: () => setFocusedPane("filter"),
+    focusSelect: () => setFocusedPane("select"),
+    hideOverlay
+  };
+  onCleanup(() => {
+    currentFileActions = null;
+    focusedPane = "select";
+    isOverlayActive = false;
+    if (rightScrollBox && rightScrollBoxOrigBg)
+      rightScrollBox.backgroundColor = rightScrollBoxOrigBg;
+  });
+  let selectRef;
+  let pathTextEl;
+  let rightNameEl;
+  let rightPathEl;
+  let rightDescEl;
+  let rightPreviewEl;
+  let rightDirListEl;
+  let rightMarkdownEl;
+  let rightCodeEl;
+  let lastClickTime = 0;
+  let lastClickIdx = 0;
+  const dimensions = useTerminalDimensions2();
+  const theme = () => props.api.theme.current;
+  let currentDir = props.initialDir || process.cwd();
+  let entries = readDir(currentDir);
+  let overlayMode = "";
+  let overlayConfirmAction = null;
+  let overlayPromptAction = null;
+  let promptInputValue = "";
+  let currentEntry = entries[0] ?? null;
+  let filterText = "";
+  let filteredEntries = entries;
+  let mainContentBox;
+  let confirmOverlayBox;
+  let promptOverlayBox;
+  let confirmTitleEl;
+  let confirmMessageEl;
+  let promptTitleEl;
+  let promptMessageEl;
+  let promptCancelBtn;
+  let promptOkBtn;
+  let promptInputEl;
+  let filterInputEl;
+  let rightScrollBox;
+  let rightScrollBoxOrigBg;
+  function applyFilter(text) {
+    filterText = text;
+    filteredEntries = text ? entries.filter((e) => e.name.toLowerCase().includes(text.toLowerCase())) : entries;
+    selectRef.options = toOptions(filteredEntries);
+    selectRef.setSelectedIndex(0);
+    currentEntry = filteredEntries[0] ?? null;
+    if (currentEntry)
+      setRightPanel(currentEntry);
+    else
+      setRightPanel(null);
+  }
+  function navigateTo(dir) {
+    currentDir = dir;
+    entries = readDir(currentDir);
+    if (filterInputEl)
+      filterInputEl.setText("");
+    filterText = "";
+    filteredEntries = entries;
+    selectRef.options = toOptions(entries);
+    pathTextEl.content = "Project Path: " + currentDir;
+    forceSelectFirst();
+    currentEntry = entries[0] ?? null;
+    if (entries[0])
+      setRightPanel(entries[0]);
+    else
+      setRightPanel(null);
+  }
+  function setRightPanel(entry) {
+    rightPreviewEl.visible = false;
+    if (rightMarkdownEl)
+      rightMarkdownEl.visible = false;
+    if (rightCodeEl)
+      rightCodeEl.visible = false;
+    if (rightDirListEl)
+      rightDirListEl.visible = false;
+    if (!entry) {
+      rightNameEl.content = "";
+      rightPathEl.content = "";
+      rightDescEl.content = "";
+      rightPreviewEl.content = "(empty directory)";
+      rightPreviewEl.visible = true;
+      return;
+    }
+    rightNameEl.content = entry.name;
+    rightPathEl.content = entry.fullPath;
+    if (entry.isDir) {
+      rightDescEl.content = "directory";
+      const items = readDir(entry.fullPath);
+      if (items.length === 0) {
+        rightDirListEl.content = "(empty directory)";
+      } else {
+        rightDirListEl.content = items.map((e) => (e.isDir ? "\uD83D\uDCC1 " : "\uD83D\uDCC4 ") + e.name + (e.isDir ? "/" : "")).join(`
+`);
+      }
+      rightDirListEl.visible = true;
+      return;
+    }
+    rightDescEl.content = describeFile(entry.name);
+    if (!isTextFile(entry.name, entry.fullPath)) {
+      rightPreviewEl.content = "(binary file)";
+      rightPreviewEl.visible = true;
+      return;
+    }
+    let content;
+    try {
+      content = readFileSync2(entry.fullPath, "utf-8");
+    } catch {
+      rightPreviewEl.content = "(preview unavailable)";
+      rightPreviewEl.visible = true;
+      return;
+    }
+    const ext = path2.extname(entry.name).toLowerCase();
+    if (ext === ".md" || ext === ".mdx" || ext === ".markdown") {
+      rightMarkdownEl.content = content;
+      rightMarkdownEl.visible = true;
+    } else {
+      rightCodeEl.content = content;
+      rightCodeEl.filetype = EXT_TO_FILETYPE2[ext] ?? "";
+      rightCodeEl.visible = true;
+    }
+  }
+  function openPreview(entry) {
+    if (entry.isDir) {
+      navigateTo(entry.fullPath);
+      return;
+    }
+    if (isTextFile(entry.name, entry.fullPath)) {
+      props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(FileViewer, {
+        api: props.api,
+        filePath: entry.fullPath,
+        onBack: () => {
+          props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(NewFileManager, {
+            api: props.api,
+            initialDir: currentDir
+          }, undefined, false, undefined, this));
+          props.api.ui.dialog.setSize("xlarge");
+        }
+      }, undefined, false, undefined, this));
+      props.api.ui.dialog.setSize("xlarge");
+      return;
+    }
+    const backDir = currentDir;
+    props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(FilePreviewDialog, {
+      api: props.api,
+      path: entry.fullPath,
+      content: "[Binary file]",
+      backDir
+    }, undefined, false, undefined, this));
+    props.api.ui.dialog.setSize("xlarge");
+  }
+  const handleSelect = (_index, option) => {
+    const fullPath = option?.value;
+    if (!fullPath)
+      return;
+    const entry = entries.find((e) => e.fullPath === fullPath);
+    if (entry)
+      openPreview(entry);
+  };
+  const handleChange = (_index, option) => {
+    const fullPath = option?.value;
+    if (!fullPath) {
+      currentEntry = null;
+      setRightPanel(null);
+      return;
+    }
+    const entry = entries.find((e) => e.fullPath === fullPath) ?? null;
+    currentEntry = entry;
+    if (entry)
+      setRightPanel(entry);
+    else
+      setRightPanel(null);
+  };
+  function showConfirm(message, onConfirm) {
+    overlayMode = "confirm";
+    isOverlayActive = true;
+    overlayConfirmAction = onConfirm;
+    confirmTitleEl.content = "Confirm";
+    confirmMessageEl.content = message;
+    mainContentBox.visible = false;
+    confirmOverlayBox.visible = true;
+    promptOverlayBox.visible = false;
+  }
+  function hideOverlay() {
+    overlayMode = "";
+    isOverlayActive = false;
+    overlayConfirmAction = null;
+    overlayPromptAction = null;
+    mainContentBox.visible = true;
+    confirmOverlayBox.visible = false;
+    promptOverlayBox.visible = false;
+    navigateTo(currentDir);
+    if (selectRef)
+      selectRef.focus();
+  }
+  function forceSelectFirst() {
+    if (selectRef && entries.length > 0) {
+      selectRef.setSelectedIndex(0);
+    }
+  }
+  function handleDelete() {
+    const entry = currentEntry;
+    if (!entry || entry.name === ".." || entry.name === ".")
+      return;
+    const label = entry.name + (entry.isDir ? "/" : "");
+    showConfirm(`Delete "${label}"?`, () => {
+      try {
+        rmSync(entry.fullPath, { recursive: entry.isDir, force: true });
+      } catch {}
+      hideOverlay();
+    });
+  }
+  function handleRename() {
+    const entry = currentEntry;
+    if (!entry || entry.name === ".." || entry.name === ".")
+      return;
+    overlayMode = "prompt";
+    isOverlayActive = true;
+    overlayPromptAction = (newName) => {
+      if (!newName || newName === entry.name) {
+        hideOverlay();
+        return;
+      }
+      const newPath = path2.join(path2.dirname(entry.fullPath), newName);
+      try {
+        renameSync(entry.fullPath, newPath);
+      } catch {}
+      hideOverlay();
+    };
+    promptInputValue = entry.name;
+    promptTitleEl.content = "Rename";
+    promptMessageEl.content = `Rename "${entry.name}" to:`;
+    if (promptInputEl) {
+      promptInputEl.setText(entry.name);
+    }
+    mainContentBox.visible = false;
+    confirmOverlayBox.visible = false;
+    promptOverlayBox.visible = true;
+    if (promptInputEl)
+      promptInputEl.focus();
+  }
+  function handleGoto() {
+    overlayMode = "prompt";
+    isOverlayActive = true;
+    overlayPromptAction = (pathStr) => {
+      if (!pathStr) {
+        hideOverlay();
+        return;
+      }
+      const home = process.env.HOME || "/";
+      const expanded = pathStr === "~" ? home : pathStr.startsWith("~/") ? path2.join(home, pathStr.slice(2)) : pathStr;
+      try {
+        const resolved = path2.resolve(currentDir, expanded);
+        const s = statSync(resolved);
+        hideOverlay();
+        if (s.isDirectory()) {
+          navigateTo(resolved);
+        } else {
+          props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(FileViewer, {
+            api: props.api,
+            filePath: resolved,
+            onBack: () => {
+              props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(NewFileManager, {
+                api: props.api,
+                initialDir: currentDir
+              }, undefined, false, undefined, this));
+              props.api.ui.dialog.setSize("xlarge");
+            }
+          }, undefined, false, undefined, this));
+          props.api.ui.dialog.setSize("xlarge");
+        }
+      } catch {
+        hideOverlay();
+      }
+    };
+    promptInputValue = "";
+    promptTitleEl.content = "Goto";
+    promptMessageEl.content = "Enter path:";
+    if (promptInputEl) {
+      promptInputEl.setText("");
+    }
+    mainContentBox.visible = false;
+    confirmOverlayBox.visible = false;
+    promptOverlayBox.visible = true;
+    if (promptInputEl)
+      promptInputEl.focus();
+  }
+  function handleCreate() {
+    overlayMode = "prompt";
+    isOverlayActive = true;
+    overlayPromptAction = (name) => {
+      if (!name) {
+        hideOverlay();
+        return;
+      }
+      const isDir = name.endsWith("/");
+      const cleanName = isDir ? name.slice(0, -1) : name;
+      const newPath = path2.join(currentDir, cleanName);
+      try {
+        if (isDir)
+          mkdirSync(newPath, { recursive: true });
+        else {
+          writeFileSync2(newPath, "", "utf-8");
+          props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(FileViewer, {
+            api: props.api,
+            filePath: newPath,
+            initialMode: "edit",
+            onBack: () => {
+              props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(NewFileManager, {
+                api: props.api,
+                initialDir: currentDir
+              }, undefined, false, undefined, this));
+              props.api.ui.dialog.setSize("xlarge");
+            }
+          }, undefined, false, undefined, this));
+          props.api.ui.dialog.setSize("xlarge");
+          return;
+        }
+      } catch {}
+      hideOverlay();
+    };
+    promptInputValue = "";
+    promptTitleEl.content = "Create";
+    promptMessageEl.content = "Enter name (trailing / for directory):";
+    if (promptInputEl) {
+      promptInputEl.setText("");
+    }
+    mainContentBox.visible = false;
+    confirmOverlayBox.visible = false;
+    promptOverlayBox.visible = true;
+    if (promptInputEl)
+      promptInputEl.focus();
+  }
+  const projectRoot = () => props.api.state.path.worktree || props.api.state.path.directory;
+  function returnToProjectRoot() {
+    const root = projectRoot();
+    if (root)
+      navigateTo(root);
+  }
+  useBindings2(() => ({
+    priority: 2,
+    bindings: [
+      { key: "ctrl+r", cmd: returnToProjectRoot }
+    ]
+  }));
+  function cycleFocus(dir) {
+    const order = ["select", "preview", "filter"];
+    const idx = order.indexOf(focusedPane);
+    const next = order[(idx + dir + 3) % 3];
+    setFocusedPane(next);
+  }
+  function setFocusedPane(pane) {
+    focusedPane = pane;
+    if (rightScrollBox && rightScrollBoxOrigBg) {
+      rightScrollBox.backgroundColor = pane === "preview" ? RGBA2.fromInts(40, 40, 50, 255) : rightScrollBoxOrigBg;
+    }
+    if (pane === "select") {
+      selectRef?.focus();
+    } else if (pane === "preview") {
+      rightScrollBox?.focus();
+    } else if (pane === "filter") {
+      filterInputEl?.focus();
+    }
+  }
+  useBindings2(() => ({
+    priority: 1,
+    bindings: [
+      { key: "tab", cmd: () => cycleFocus(1) },
+      { key: "shift+tab", cmd: () => cycleFocus(-1) }
+    ]
+  }));
+  useBindings2(() => ({
+    priority: 1,
+    enabled: () => focusedPane === "preview",
+    bindings: [
+      { key: "up", cmd: () => rightScrollBox?.scrollBy(-1) },
+      { key: "down", cmd: () => rightScrollBox?.scrollBy(1) },
+      { key: "pageup", cmd: () => {
+        if (rightScrollBox) {
+          const h = rightScrollBox.height;
+          if (h > 0)
+            rightScrollBox.scrollTop -= h;
+        }
+      } },
+      { key: "pagedown", cmd: () => {
+        if (rightScrollBox) {
+          const h = rightScrollBox.height;
+          if (h > 0)
+            rightScrollBox.scrollTop += h;
+        }
+      } },
+      { key: "home", cmd: () => {
+        if (rightScrollBox)
+          rightScrollBox.scrollTop = 0;
+      } },
+      { key: "end", cmd: () => {
+        if (rightScrollBox)
+          rightScrollBox.scrollTop = rightScrollBox.scrollHeight - rightScrollBox.height;
+      } }
+    ]
+  }));
+  useBindings2(() => ({
+    priority: 1,
+    enabled: () => focusedPane === "select",
+    bindings: [
+      { key: "pageup", cmd: () => selectRef?.moveUp(10) },
+      { key: "pagedown", cmd: () => selectRef?.moveDown(10) },
+      { key: "home", cmd: () => {
+        if (selectRef)
+          selectRef.setSelectedIndex(0);
+      } },
+      { key: "end", cmd: () => {
+        if (selectRef)
+          selectRef.setSelectedIndex(filteredEntries.length - 1);
+      } }
+    ]
+  }));
+  const panelWidth = () => Math.min(Math.max(dimensions().width - 2, 60), 116);
+  const panelHeight = () => Math.max(Math.floor(dimensions().height * 0.78) - 2, 22);
+  const leftWidth = () => Math.floor(panelWidth() * 0.4);
+  const rightWidth = () => panelWidth() - leftWidth();
+  const first = filteredEntries[0];
+  return /* @__PURE__ */ jsxDEV2("box", {
+    width: panelWidth(),
+    height: panelHeight(),
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV2("box", {
+        paddingLeft: 2,
+        paddingRight: 2,
+        flexShrink: 0,
+        border: ["bottom"],
+        borderColor: theme().textMuted,
+        flexDirection: "row",
+        children: [
+          /* @__PURE__ */ jsxDEV2("text", {
+            ref: (el) => {
+              pathTextEl = el;
+            },
+            fg: theme().text,
+            children: [
+              "Project Path: ",
+              currentDir
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexGrow: 1
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexDirection: "row",
+            gap: 3,
+            children: [
+              /* @__PURE__ */ jsxDEV2("box", {
+                flexDirection: "row",
+                gap: 0,
+                onMouseUp: () => returnToProjectRoot(),
+                children: [
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: HINT_FG2,
+                    children: "[Ctrl+R]"
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: FG2,
+                    children: " Return"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV2("box", {
+                flexDirection: "row",
+                gap: 0,
+                onMouseUp: () => props.api.ui.dialog.clear(),
+                children: [
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: HINT_FG2,
+                    children: "[ESC]"
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: FG2,
+                    children: " Close"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV2("box", {
+        flexDirection: "row",
+        flexGrow: 1,
+        minHeight: 5,
+        children: [
+          /* @__PURE__ */ jsxDEV2("box", {
+            ref: (el) => {
+              mainContentBox = el;
+            },
+            flexDirection: "row",
+            flexGrow: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV2("select", {
+                ref: (el) => {
+                  selectRef = el;
+                },
+                options: toOptions(filteredEntries),
+                showDescription: false,
+                focused: true,
+                onChange: handleChange,
+                onSelect: handleSelect,
+                height: "100%",
+                width: leftWidth(),
+                onMouseDown: (event) => {
+                  selectRef?.focus();
+                  setFocusedPane("select");
+                  const idx = Math.floor(event.y - selectRef.screenY);
+                  if (idx >= 0 && idx < filteredEntries.length) {
+                    const now = Date.now();
+                    if (idx === lastClickIdx && now - lastClickTime < 500) {
+                      handleSelect(idx, selectRef.options[idx]);
+                    } else {
+                      selectRef.setSelectedIndex(idx);
+                    }
+                    lastClickTime = now;
+                    lastClickIdx = idx;
+                  }
+                },
+                onMouseScroll: (event) => {
+                  if (!event.scroll)
+                    return;
+                  selectRef?.focus();
+                  setFocusedPane("select");
+                  const cur = selectRef.getSelectedIndex();
+                  if (event.scroll.direction === "down" && cur < filteredEntries.length - 1) {
+                    selectRef.setSelectedIndex(Math.min(filteredEntries.length - 1, cur + event.scroll.delta));
+                  } else if (event.scroll.direction === "up" && cur > 0) {
+                    selectRef.setSelectedIndex(Math.max(0, cur - event.scroll.delta));
+                  }
+                }
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("scrollbox", {
+                ref: (el) => {
+                  rightScrollBox = el;
+                  rightScrollBoxOrigBg = el.backgroundColor;
+                },
+                width: rightWidth(),
+                height: "100%",
+                backgroundColor: theme().backgroundPanel,
+                scrollbarOptions: { visible: false },
+                onMouseDown: () => {
+                  setFocusedPane("preview");
+                },
+                children: /* @__PURE__ */ jsxDEV2("box", {
+                  padding: 1,
+                  flexDirection: "column",
+                  gap: 1,
+                  children: [
+                    /* @__PURE__ */ jsxDEV2("text", {
+                      ref: (el) => {
+                        rightNameEl = el;
+                      },
+                      fg: theme().text,
+                      children: first ? first.name : ""
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("text", {
+                      ref: (el) => {
+                        rightPathEl = el;
+                      },
+                      fg: theme().textMuted,
+                      children: first ? first.fullPath : ""
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("text", {
+                      ref: (el) => {
+                        rightDescEl = el;
+                      },
+                      fg: theme().textMuted,
+                      children: first ? first.isDir ? "directory" : describeFile(first.name) : ""
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("text", {
+                      ref: (el) => {
+                        rightPreviewEl = el;
+                      },
+                      fg: theme().text,
+                      visible: false
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("text", {
+                      ref: (el) => {
+                        rightDirListEl = el;
+                      },
+                      fg: theme().text,
+                      visible: false
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("markdown", {
+                      ref: (el) => {
+                        rightMarkdownEl = el;
+                      },
+                      content: "",
+                      syntaxStyle: SYNTAX_STYLE2,
+                      conceal: true,
+                      fg: theme().text,
+                      width: "100%",
+                      visible: false
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("code", {
+                      ref: (el) => {
+                        rightCodeEl = el;
+                      },
+                      content: "",
+                      filetype: "",
+                      syntaxStyle: SYNTAX_STYLE2,
+                      width: "100%",
+                      visible: false
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            ref: (el) => {
+              confirmOverlayBox = el;
+            },
+            visible: false,
+            flexDirection: "column",
+            flexGrow: 1,
+            justifyContent: "center",
+            alignItems: "center",
+            backgroundColor: theme().backgroundPanel,
+            children: /* @__PURE__ */ jsxDEV2("box", {
+              padding: 2,
+              flexDirection: "column",
+              gap: 1,
+              backgroundColor: theme().backgroundElement,
+              children: [
+                /* @__PURE__ */ jsxDEV2("text", {
+                  ref: (el) => {
+                    confirmTitleEl = el;
+                  },
+                  fg: theme().text
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV2("text", {
+                  ref: (el) => {
+                    confirmMessageEl = el;
+                  },
+                  fg: theme().textMuted
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV2("box", {
+                  flexDirection: "row",
+                  justifyContent: "flex-end",
+                  gap: 1,
+                  children: [
+                    /* @__PURE__ */ jsxDEV2("box", {
+                      paddingLeft: 2,
+                      paddingRight: 2,
+                      flexDirection: "row",
+                      onMouseUp: () => hideOverlay(),
+                      children: [
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: HINT_FG2,
+                          children: "[ESC]"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: FG2,
+                          children: " Cancel"
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("box", {
+                      paddingLeft: 2,
+                      paddingRight: 2,
+                      flexDirection: "row",
+                      onMouseUp: () => overlayConfirmAction?.(),
+                      children: [
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: HINT_FG2,
+                          children: "[Enter]"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: FG2,
+                          children: " Confirm"
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            ref: (el) => {
+              promptOverlayBox = el;
+            },
+            visible: false,
+            flexDirection: "column",
+            flexGrow: 1,
+            justifyContent: "center",
+            alignItems: "center",
+            backgroundColor: theme().backgroundPanel,
+            children: /* @__PURE__ */ jsxDEV2("box", {
+              padding: 2,
+              flexDirection: "column",
+              gap: 1,
+              backgroundColor: theme().backgroundElement,
+              children: [
+                /* @__PURE__ */ jsxDEV2("text", {
+                  ref: (el) => {
+                    promptTitleEl = el;
+                  },
+                  fg: theme().text
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV2("text", {
+                  ref: (el) => {
+                    promptMessageEl = el;
+                  },
+                  fg: theme().textMuted
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV2("input", {
+                  ref: (el) => {
+                    promptInputEl = el;
+                  },
+                  placeholder: "Name...",
+                  width: 40,
+                  onInput: (val) => {
+                    promptInputValue = val;
+                  },
+                  onSubmit: () => overlayPromptAction?.(promptInputValue)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV2("box", {
+                  flexDirection: "row",
+                  justifyContent: "flex-end",
+                  gap: 1,
+                  children: [
+                    /* @__PURE__ */ jsxDEV2("box", {
+                      paddingLeft: 2,
+                      paddingRight: 2,
+                      flexDirection: "row",
+                      onMouseUp: () => hideOverlay(),
+                      children: [
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: HINT_FG2,
+                          children: "[ESC]"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: FG2,
+                          children: " Cancel"
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this),
+                    /* @__PURE__ */ jsxDEV2("box", {
+                      paddingLeft: 2,
+                      paddingRight: 2,
+                      flexDirection: "row",
+                      onMouseUp: () => overlayPromptAction?.(promptInputValue),
+                      children: [
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: HINT_FG2,
+                          children: "[Enter]"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV2("text", {
+                          fg: FG2,
+                          children: " Confirm"
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV2("box", {
+        paddingLeft: 2,
+        paddingTop: 1,
+        flexShrink: 0,
+        flexDirection: "row",
+        gap: 3,
+        children: [
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseUp: () => handleCreate(),
+            children: [
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: theme().textMuted,
+                children: "[F7]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: FG2,
+                children: " New"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseUp: () => handleRename(),
+            children: [
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: theme().textMuted,
+                children: "[F2]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: FG2,
+                children: " Rename"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseUp: () => handleDelete(),
+            children: [
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: theme().textMuted,
+                children: "[Del]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: FG2,
+                children: " Delete"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseUp: () => handleGoto(),
+            children: [
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: theme().textMuted,
+                children: "[Ctrl+G]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: FG2,
+                children: " Goto"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("box", {
+            flexGrow: 1,
+            flexDirection: "row",
+            border: ["bottom"],
+            borderColor: theme().textMuted,
+            onMouseDown: () => {
+              setFocusedPane("filter");
+            },
+            children: [
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: HINT_FG2,
+                children: "[Ctrl+F]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("text", {
+                fg: theme().textMuted,
+                children: " "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("input", {
+                ref: (el) => {
+                  filterInputEl = el;
+                },
+                placeholder: "Filter...",
+                onInput: (val) => applyFilter(val),
+                flexGrow: 1
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function FilePreviewDialog(props) {
+  const theme = () => props.api.theme.current;
+  useBindings2(() => ({
+    bindings: [
+      {
+        key: "escape",
+        cmd: () => {
+          props.api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(NewFileManager, {
+            api: props.api,
+            initialDir: props.backDir
+          }, undefined, false, undefined, this));
+          props.api.ui.dialog.setSize("xlarge");
+        }
+      }
+    ]
+  }));
+  return /* @__PURE__ */ jsxDEV2("scrollbox", {
+    width: "100%",
+    height: "100%",
+    backgroundColor: theme().backgroundPanel,
+    scrollbarOptions: { visible: false },
+    children: /* @__PURE__ */ jsxDEV2("box", {
+      padding: 1,
+      children: [
+        /* @__PURE__ */ jsxDEV2("text", {
+          fg: theme().textMuted,
+          children: props.path
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV2("text", {
+          fg: theme().text,
+          children: props.content
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/panel-permissions.tsx
+import { RGBA as RGBA3, SyntaxStyle as SyntaxStyle3 } from "@opentui/core";
+import { useTerminalDimensions as useTerminalDimensions3 } from "@opentui/solid";
+import { useBindings as useBindings3 } from "@opentui/keymap/solid";
+
+// src/config-helper.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync } from "fs";
+import path3 from "path";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path3) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path3) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function stripComments(text, replaceCh) {
+  let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
+  do {
+    pos = _scanner.getPosition();
+    kind = _scanner.scan();
+    switch (kind) {
+      case 12:
+      case 13:
+      case 17:
+        if (offset !== pos) {
+          parts.push(text.substring(offset, pos));
+        }
+        if (replaceCh !== undefined) {
+          parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
+        }
+        offset = _scanner.getPosition();
+        break;
+    }
+  } while (kind !== 17);
+  return parts.join("");
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path3 = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path3.length > 0) {
+    lastSegment = path3.pop();
+    parent = findNodeAtLocation(root, path3);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var stripComments2 = stripComments;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function modify(text, path3, value, options) {
+  return setProperty(text, path3, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+
+// src/config-helper.ts
+function findConfig(directory, worktree) {
+  let current = path3.resolve(directory);
+  const root = path3.resolve(worktree);
+  while (current.startsWith(root)) {
+    for (const name of ["opencode.jsonc", "opencode.json"]) {
+      const fp = path3.join(current, name);
+      if (existsSync(fp))
+        return fp;
+    }
+    if (current === root)
+      break;
+    const next = path3.dirname(current);
+    if (next === current)
+      break;
+    current = next;
+  }
+  return null;
+}
+function detectIndent(text) {
+  const m = text.match(/^( {2,4}|\t)/m);
+  if (m) {
+    const t = m[1];
+    return { tabSize: t === "\t" ? 1 : t.length, insertSpaces: t !== "\t" };
+  }
+  return { tabSize: 2, insertSpaces: true };
+}
+function readPermissions(filePath) {
+  const result = { allow: [], deny: [] };
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    const text = stripComments2(raw);
+    const data = JSON.parse(text);
+    const skill = data?.permission?.skill;
+    if (!skill)
+      return result;
+    if (typeof skill === "string") {
+      if (skill === "allow")
+        result.allow.push("*");
+      else if (skill === "deny")
+        result.deny.push("*");
+      return result;
+    }
+    if (typeof skill === "object" && !Array.isArray(skill)) {
+      for (const [k, v] of Object.entries(skill)) {
+        if (v === "allow")
+          result.allow.push(k);
+        else if (v === "deny")
+          result.deny.push(k);
+      }
+    }
+  } catch {}
+  return result;
+}
+function setPermission(filePath, skillName, action) {
+  try {
+    let text = readFileSync3(filePath, "utf-8");
+    const opts = { formattingOptions: detectIndent(text) };
+    const edits = modify(text, ["permission", "skill", skillName], action, opts);
+    text = applyEdits(text, edits);
+    writeFileSync3(filePath, text, "utf-8");
+  } catch {}
+}
+function readTools(filePath) {
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    const text = stripComments2(raw);
+    const data = JSON.parse(text);
+    const permission = data?.permission;
+    if (!permission || typeof permission !== "object")
+      return {};
+    const result = {};
+    for (const [k, v] of Object.entries(permission)) {
+      if (k === "skill")
+        continue;
+      if (typeof v === "string")
+        result[k] = v;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function setToolPermission(filePath, tool, action) {
+  try {
+    let text = readFileSync3(filePath, "utf-8");
+    const opts = { formattingOptions: detectIndent(text) };
+    const edits = modify(text, ["permission", tool], action, opts);
+    text = applyEdits(text, edits);
+    writeFileSync3(filePath, text, "utf-8");
+  } catch {}
+}
+function readMCPs(filePath) {
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    const text = stripComments2(raw);
+    const data = JSON.parse(text);
+    const mcp = data?.mcp;
+    if (!mcp || typeof mcp !== "object")
+      return [];
+    return Object.entries(mcp).map(([name, cfg]) => ({
+      name,
+      type: cfg?.type ?? "local",
+      enabled: cfg?.enabled !== false,
+      command: cfg?.command,
+      url: cfg?.url
+    }));
+  } catch {
+    return [];
+  }
+}
+function setMCPEnabled(filePath, name, enabled) {
+  try {
+    let text = readFileSync3(filePath, "utf-8");
+    const opts = { formattingOptions: detectIndent(text) };
+    const edits = modify(text, ["mcp", name, "enabled"], enabled, opts);
+    text = applyEdits(text, edits);
+    writeFileSync3(filePath, text, "utf-8");
+  } catch {}
+}
+
+// src/panel-permissions.tsx
+import { jsxDEV as jsxDEV3 } from "@opentui/solid/jsx-dev-runtime";
+var HINT_FG3 = RGBA3.fromInts(180, 180, 180, 255);
+var FG3 = RGBA3.fromInts(255, 255, 255, 255);
+function PermissionsPanel(props) {
+  const dimensions = useTerminalDimensions3();
+  const theme = () => props.api.theme.current;
+  let activeTab = 0;
+  let tabSkillsEl;
+  let tabToolsEl;
+  let tabMcpEl;
+  let selectRef;
+  let skillsDetailBox;
+  let toolsDetailBox;
+  let mcpsDetailBox;
+  let skNameEl;
+  let skPathEl;
+  let skCopyEl;
+  let skStatusEl;
+  let skLastClick = 0;
+  let skLastIdx = -1;
+  const skAllowSet = new Set(props.initialSkillAllow);
+  const skDenySet = new Set(props.initialSkillDeny);
+  const skCatchAllDeny = skDenySet.has("*");
+  function skIsAllow(s) {
+    if (skAllowSet.has("*"))
+      return true;
+    if (skDenySet.has(s.name))
+      return false;
+    if (skAllowSet.has(s.name))
+      return true;
+    return !skCatchAllDeny;
+  }
+  const skToOptions = () => props.skills.map((s) => ({
+    name: (skIsAllow(s) ? "[allow] " : "[deny]  ") + s.name,
+    description: s.description ?? "",
+    value: s.name
+  }));
+  function skUpdateDetail(s) {
+    if (!s) {
+      skNameEl.content = "";
+      skPathEl.content = "";
+      skCopyEl.content = "";
+      skStatusEl.content = "";
+      return;
+    }
+    skNameEl.content = s.name;
+    skPathEl.content = s.location;
+    skCopyEl.content = "[Copy]";
+    skStatusEl.content = skIsAllow(s) ? "allowed" : "denied";
+  }
+  function skToggle(name) {
+    const s = props.skills.find((x) => x.name === name);
+    if (!s)
+      return;
+    const was = skIsAllow(s);
+    setPermission(props.configFile, name, was ? "deny" : "allow");
+    skAllowSet.delete(name);
+    skDenySet.delete(name);
+    if (was)
+      skDenySet.add(name);
+    else
+      skAllowSet.add(name);
+    selectRef.options = currentOptions();
+    skUpdateDetail(s);
+  }
+  let tlNameEl;
+  let tlActionEl;
+  let tlLastClick = 0;
+  let tlLastIdx = -1;
+  const tlToOptions = () => props.tools.map((t) => ({
+    name: (t.action === "allow" ? "[allow] " : t.action === "ask" ? "[ask]   " : "[deny]  ") + t.name,
+    description: t.action,
+    value: t.name
+  }));
+  function tlUpdateDetail(t) {
+    if (!t) {
+      tlNameEl.content = "";
+      tlActionEl.content = "";
+      return;
+    }
+    tlNameEl.content = t.name;
+    tlActionEl.content = t.action === "allow" ? "allowed" : t.action === "ask" ? "ask" : "denied";
+  }
+  function tlToggle(name) {
+    const t = props.tools.find((x) => x.name === name);
+    if (!t)
+      return;
+    const order = ["allow", "ask", "deny"];
+    const idx = order.indexOf(t.action);
+    const next = order[(idx + 1) % order.length];
+    setToolPermission(props.configFile, name, next);
+    t.action = next;
+    selectRef.options = currentOptions();
+    tlUpdateDetail(t);
+  }
+  let mcpNameEl;
+  let mcpTypeEl;
+  let mcpDetailEl;
+  let mcpStatusEl;
+  let mcpLastClick = 0;
+  let mcpLastIdx = -1;
+  const mcpToOptions = () => props.mcps.map((m) => ({
+    name: (m.enabled ? "[enabled] " : "[disabled]") + m.name,
+    description: m.type,
+    value: m.name
+  }));
+  function mcpUpdateDetail(m) {
+    if (!m) {
+      mcpNameEl.content = "";
+      mcpTypeEl.content = "";
+      mcpDetailEl.content = "";
+      mcpStatusEl.content = "";
+      return;
+    }
+    mcpNameEl.content = m.name;
+    mcpTypeEl.content = m.type;
+    mcpStatusEl.content = m.enabled ? "enabled" : "disabled";
+    mcpDetailEl.content = m.type === "local" ? m.command?.join(" ") ?? "" : m.url ?? "";
+  }
+  function mcpToggle(name) {
+    const m = props.mcps.find((x) => x.name === name);
+    if (!m)
+      return;
+    const next = !m.enabled;
+    setMCPEnabled(props.configFile, name, next);
+    m.enabled = next;
+    selectRef.options = currentOptions();
+    mcpUpdateDetail(m);
+  }
+  function currentOptions() {
+    if (activeTab === 0)
+      return skToOptions();
+    if (activeTab === 1)
+      return tlToOptions();
+    return mcpToOptions();
+  }
+  const handleChange = (_i, opt) => {
+    const name = opt?.value;
+    if (!name)
+      return;
+    if (activeTab === 0) {
+      skUpdateDetail(props.skills.find((s) => s.name === name) ?? null);
+    } else if (activeTab === 1) {
+      tlUpdateDetail(props.tools.find((t) => t.name === name) ?? null);
+    } else {
+      mcpUpdateDetail(props.mcps.find((m) => m.name === name) ?? null);
+    }
+  };
+  const handleSelect = (_i, opt) => {
+    const name = opt?.value;
+    if (!name)
+      return;
+    if (activeTab === 0)
+      skToggle(name);
+    else if (activeTab === 1)
+      tlToggle(name);
+    else
+      mcpToggle(name);
+  };
+  const defaultTabColor = () => theme().textMuted;
+  const activeTabColor = () => theme().text;
+  function switchTab(idx) {
+    activeTab = idx;
+    tabSkillsEl.fg = idx === 0 ? activeTabColor() : defaultTabColor();
+    tabToolsEl.fg = idx === 1 ? activeTabColor() : defaultTabColor();
+    tabMcpEl.fg = idx === 2 ? activeTabColor() : defaultTabColor();
+    skillsDetailBox.visible = idx === 0;
+    toolsDetailBox.visible = idx === 1;
+    mcpsDetailBox.visible = idx === 2;
+    selectRef.options = currentOptions();
+  }
+  function cycleTab() {
+    switchTab((activeTab + 1) % 3);
+  }
+  useBindings3(() => ({
+    priority: 2,
+    bindings: [
+      { key: "1", cmd: () => switchTab(0) },
+      { key: "2", cmd: () => switchTab(1) },
+      { key: "3", cmd: () => switchTab(2) },
+      { key: "tab", cmd: cycleTab }
+    ]
+  }));
+  const syntaxStyle = () => SyntaxStyle3.fromStyles({ default: { fg: theme().markdownText } });
+  const panelWidth = () => Math.min(Math.max(dimensions().width - 2, 60), 116);
+  const panelHeight = () => Math.max(Math.floor(dimensions().height * 0.78) - 2, 22);
+  const halfWidth = () => Math.floor(panelWidth() / 2);
+  const firstSkill = props.skills[0];
+  const firstTool = props.tools[0];
+  const firstMcp = props.mcps[0];
+  return /* @__PURE__ */ jsxDEV3("box", {
+    width: panelWidth(),
+    height: panelHeight(),
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV3("box", {
+        paddingLeft: 2,
+        paddingRight: 2,
+        flexShrink: 0,
+        flexDirection: "row",
+        children: [
+          /* @__PURE__ */ jsxDEV3("text", {
+            fg: theme().text,
+            children: "Permissions"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("box", {
+            flexGrow: 1
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("box", {
+            flexDirection: "row",
+            onMouseUp: () => props.api.ui.dialog.clear(),
+            children: [
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: HINT_FG3,
+                children: "[ESC]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: FG3,
+                children: " Close"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV3("box", {
+        paddingLeft: 2,
+        flexShrink: 0,
+        children: /* @__PURE__ */ jsxDEV3("text", {
+          fg: theme().textMuted,
+          children: [
+            "Path: ",
+            props.configFile
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3("box", {
+        flexDirection: "row",
+        gap: 2,
+        paddingLeft: 2,
+        paddingTop: 1,
+        flexShrink: 0,
+        border: ["bottom"],
+        borderColor: theme().textMuted,
+        children: [
+          /* @__PURE__ */ jsxDEV3("text", {
+            ref: (el) => {
+              tabSkillsEl = el;
+            },
+            fg: activeTabColor(),
+            onMouseDown: () => switchTab(0),
+            children: "Skills"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("text", {
+            ref: (el) => {
+              tabToolsEl = el;
+            },
+            fg: defaultTabColor(),
+            onMouseDown: () => switchTab(1),
+            children: "Tools"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("text", {
+            ref: (el) => {
+              tabMcpEl = el;
+            },
+            fg: defaultTabColor(),
+            onMouseDown: () => switchTab(2),
+            children: "MCPs"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV3("box", {
+        flexDirection: "row",
+        flexGrow: 1,
+        minHeight: 5,
+        children: [
+          /* @__PURE__ */ jsxDEV3("select", {
+            ref: (el) => {
+              selectRef = el;
+            },
+            options: currentOptions(),
+            showDescription: false,
+            focused: true,
+            onChange: handleChange,
+            onSelect: handleSelect,
+            height: "100%",
+            width: halfWidth(),
+            onMouseDown: (event) => {
+              const len = activeTab === 0 ? props.skills.length : activeTab === 1 ? props.tools.length : props.mcps.length;
+              const idx = Math.floor(event.y - selectRef.screenY);
+              if (idx >= 0 && idx < len) {
+                const now = Date.now();
+                const lc = activeTab === 0 ? skLastClick : activeTab === 1 ? tlLastClick : mcpLastClick;
+                const li = activeTab === 0 ? skLastIdx : activeTab === 1 ? tlLastIdx : mcpLastIdx;
+                if (idx === li && now - lc < 500) {
+                  handleSelect(idx, selectRef.options[idx]);
+                } else {
+                  selectRef.setSelectedIndex(idx);
+                }
+                if (activeTab === 0) {
+                  skLastClick = now;
+                  skLastIdx = idx;
+                } else if (activeTab === 1) {
+                  tlLastClick = now;
+                  tlLastIdx = idx;
+                } else {
+                  mcpLastClick = now;
+                  mcpLastIdx = idx;
+                }
+              }
+            }
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("scrollbox", {
+            width: halfWidth(),
+            height: "100%",
+            backgroundColor: theme().backgroundPanel,
+            scrollbarOptions: { visible: false },
+            children: [
+              /* @__PURE__ */ jsxDEV3("box", {
+                ref: (el) => {
+                  skillsDetailBox = el;
+                },
+                padding: 1,
+                flexDirection: "column",
+                gap: 1,
+                children: [
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      skNameEl = el;
+                    },
+                    fg: theme().text,
+                    children: firstSkill?.name ?? ""
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      skStatusEl = el;
+                    },
+                    fg: theme().textMuted,
+                    children: firstSkill ? skIsAllow(firstSkill) ? "allowed" : "denied" : ""
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("box", {
+                    flexDirection: "row",
+                    gap: 1,
+                    children: [
+                      /* @__PURE__ */ jsxDEV3("text", {
+                        ref: (el) => {
+                          skPathEl = el;
+                        },
+                        fg: theme().textMuted,
+                        children: firstSkill?.location ?? ""
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV3("text", {
+                        ref: (el) => {
+                          skCopyEl = el;
+                        },
+                        fg: theme().primary,
+                        onMouseDown: () => {
+                          if (!firstSkill)
+                            return;
+                          props.api.renderer.copyToClipboardOSC52(firstSkill.location);
+                          skCopyEl.content = "Copied!";
+                        },
+                        children: "[Copy]"
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("markdown", {
+                    content: firstSkill?.description ?? "",
+                    syntaxStyle: syntaxStyle(),
+                    fg: theme().markdownText
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV3("box", {
+                ref: (el) => {
+                  toolsDetailBox = el;
+                },
+                visible: false,
+                padding: 1,
+                flexDirection: "column",
+                gap: 1,
+                children: [
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      tlNameEl = el;
+                    },
+                    fg: theme().text,
+                    children: firstTool?.name ?? ""
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      tlActionEl = el;
+                    },
+                    fg: theme().textMuted,
+                    children: firstTool ? firstTool.action === "allow" ? "allowed" : "denied" : ""
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV3("box", {
+                ref: (el) => {
+                  mcpsDetailBox = el;
+                },
+                visible: false,
+                padding: 1,
+                flexDirection: "column",
+                gap: 1,
+                children: [
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      mcpNameEl = el;
+                    },
+                    fg: theme().text,
+                    children: firstMcp?.name ?? ""
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      mcpTypeEl = el;
+                    },
+                    fg: theme().textMuted,
+                    children: firstMcp?.type ?? ""
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      mcpDetailEl = el;
+                    },
+                    fg: theme().text,
+                    children: firstMcp ? firstMcp.type === "local" ? firstMcp.command?.join(" ") ?? "" : firstMcp.url ?? "" : ""
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV3("text", {
+                    ref: (el) => {
+                      mcpStatusEl = el;
+                    },
+                    fg: theme().textMuted,
+                    children: firstMcp ? firstMcp.enabled ? "enabled" : "disabled" : ""
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV3("box", {
+        paddingLeft: 2,
+        paddingTop: 1,
+        paddingBottom: 1,
+        flexShrink: 0,
+        flexDirection: "row",
+        gap: 3,
+        children: [
+          /* @__PURE__ */ jsxDEV3("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseDown: () => switchTab(0),
+            children: [
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: HINT_FG3,
+                children: "[1]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: FG3,
+                children: " Skills"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV3("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseDown: () => switchTab(1),
+            children: [
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: HINT_FG3,
+                children: "[2]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: FG3,
+                children: " Tools"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV3("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseDown: () => switchTab(2),
+            children: [
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: HINT_FG3,
+                children: "[3]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV3("text", {
+                fg: FG3,
+                children: " MCPs"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/bottom-bar.tsx
+import { jsxDEV as jsxDEV4 } from "@opentui/solid/jsx-dev-runtime";
+function showPanel(api, panel) {
+  api.ui.dialog.replace(panel);
+  api.ui.dialog.setSize("xlarge");
+}
+async function showPermissions(api) {
+  const directory = api.state.path.directory;
+  const worktree = api.state.path.worktree;
+  let filePath = findConfig(directory, worktree);
+  if (!filePath) {
+    filePath = path4.join(directory, "opencode.jsonc");
+    if (!existsSync2(filePath)) {
+      writeFileSync4(filePath, `{
+  "$schema": "https://opencode.ai/config.json"
+}
+`, "utf-8");
+    }
+  }
+  const [skillsResult] = await Promise.all([
+    api.client.app.skills({}, { throwOnError: true }).then((r) => r.data ?? []).catch(() => [])
+  ]);
+  const skills = skillsResult.map((s) => ({
+    name: s.name,
+    description: s.description,
+    location: s.location
+  }));
+  const { allow: skAllow, deny: skDeny } = filePath ? readPermissions(filePath) : { allow: [], deny: [] };
+  const rawTools = filePath ? readTools(filePath) : {};
+  const toolNames = [...new Set([...Object.keys(rawTools), ...["bash", "edit", "write", "read", "grep", "glob", "lsp", "patch", "skill", "todowrite", "webfetch", "websearch", "question"]])].sort();
+  const tools = toolNames.map((name) => {
+    const action = rawTools[name];
+    return {
+      name,
+      action: action === "ask" || action === "deny" ? action : "allow"
+    };
+  });
+  const mcps = filePath ? readMCPs(filePath) : [];
+  showPanel(api, () => /* @__PURE__ */ jsxDEV4(PermissionsPanel, {
+    api,
+    configFile: filePath,
+    skills,
+    initialSkillAllow: skAllow,
+    initialSkillDeny: skDeny,
+    tools,
+    mcps
+  }, undefined, false, undefined, this));
+}
+var BG = RGBA4.fromInts(30, 30, 30, 255);
+var FG4 = RGBA4.fromInts(255, 255, 255, 255);
+var HINT_FG4 = RGBA4.fromInts(180, 180, 180, 255);
+var EmptyBorder = {
+  topLeft: "",
+  bottomLeft: "",
+  vertical: "",
+  topRight: "",
+  bottomRight: "",
+  horizontal: " ",
+  bottomT: "",
+  topT: "",
+  cross: "",
+  leftT: "",
+  rightT: ""
+};
+function BottomBar(props) {
+  const api = props.api;
+  useBindings4(() => ({
+    priority: 1,
+    commands: [
+      {
+        name: "home.files.open",
+        title: "Files",
+        category: "Tools",
+        namespace: "palette",
+        slashName: "files",
+        slashAliases: ["file"],
+        run() {
+          showPanel(api, () => /* @__PURE__ */ jsxDEV4(NewFileManager, {
+            api
+          }, undefined, false, undefined, this));
+        }
+      },
+      {
+        name: "home.permissions.open",
+        title: "Permissions",
+        category: "Tools",
+        namespace: "palette",
+        slashName: "permissions",
+        run() {
+          showPermissions(api);
+        }
+      }
+    ],
+    bindings: [
+      { key: "f1", cmd: "home.files.open", desc: "Open file browser" },
+      { key: "f3", cmd: "home.permissions.open", desc: "Open permissions" },
+      { key: "f7", cmd: () => currentFileActions?.create?.() },
+      { key: "f2", cmd: () => currentFileActions?.rename?.() },
+      { key: "ctrl+r", cmd: () => currentFileActions?.rename?.() },
+      { key: "delete", cmd: () => currentFileActions?.delete?.() },
+      { key: "ctrl+g", cmd: () => currentFileActions?.goto?.() },
+      { key: "ctrl+f", cmd: () => currentFileActions?.focusFilter?.() },
+      { key: "escape", cmd: () => {
+        if (isOverlayActive)
+          currentFileActions?.hideOverlay?.();
+        else if (focusedPane === "filter" || focusedPane === "preview")
+          currentFileActions?.focusSelect?.();
+        else
+          api.ui.dialog.clear();
+        return true;
+      } }
+    ]
+  }));
+  return /* @__PURE__ */ jsxDEV4("box", {
+    width: "100%",
+    flexDirection: "column",
+    flexShrink: 0,
+    zIndex: 100,
+    children: [
+      /* @__PURE__ */ jsxDEV4("box", {
+        position: "absolute",
+        top: -1,
+        left: 0,
+        width: "100%",
+        height: 1,
+        border: ["bottom"],
+        borderColor: BG,
+        customBorderChars: { ...EmptyBorder, horizontal: "\u2584" }
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV4("box", {
+        height: 1,
+        paddingLeft: 2,
+        paddingRight: 2,
+        flexDirection: "row",
+        flexShrink: 0,
+        gap: 3,
+        backgroundColor: BG,
+        children: [
+          /* @__PURE__ */ jsxDEV4("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseUp: () => showPanel(api, () => /* @__PURE__ */ jsxDEV4(NewFileManager, {
+              api
+            }, undefined, false, undefined, this)),
+            children: [
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: HINT_FG4,
+                children: "[F1]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: FG4,
+                children: " Files"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV4("box", {
+            flexDirection: "row",
+            gap: 0,
+            onMouseUp: () => showPermissions(api),
+            children: [
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: HINT_FG4,
+                children: "[F3]"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: FG4,
+                children: " Permissions"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV4("box", {
+        height: 1,
+        flexShrink: 0,
+        border: ["bottom"],
+        borderColor: BG,
+        customBorderChars: { ...EmptyBorder, horizontal: "\u2580" }
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/index.tsx
+import { jsxDEV as jsxDEV5 } from "@opentui/solid/jsx-dev-runtime";
+var plugin = async (api) => {
+  api.slots.register({
+    order: 100,
+    slots: {
+      app_bottom() {
+        return /* @__PURE__ */ jsxDEV5(BottomBar, {
+          api
+        }, undefined, false, undefined, this);
+      }
+    }
+  });
+};
+var src_default = { id: "opencode-project-panel", tui: plugin };
+export {
+  src_default as default
+};