opencode-add-dir 1.4.0 → 1.6.0

package/README.md

@@ -6,12 +6,8 @@ When you need an agent to read, edit, or search files outside the current projec
 
 ## Quick Start
 
-Add to your `opencode.json`:
-
-```json
-{
-  "plugin": ["opencode-add-dir"]
-}
+```bash
+opencode plugin opencode-add-dir -g
 ```
 
 Restart OpenCode. Done.
@@ -20,15 +16,13 @@ Restart OpenCode. Done.
 <summary>Alternative: setup CLI</summary>
 
 ```bash
-bunx opencode-add-dir-setup
+npx opencode-add-dir-setup
 ```
 
-Automatically adds the plugin to your global `opencode.json`.
-
 </details>
 
 <details>
-<summary>Alternative: local file</summary>
+<summary>Alternative: local development</summary>
 
 ```bash
 git clone https://github.com/kuzeofficial/add-dir-opencode.git
@@ -36,77 +30,78 @@ cd add-dir-opencode
 bun install && bun run deploy
 ```
 
-Bundles to `~/.config/opencode/plugins/add-dir.js`.
+Add the local path to both configs:
+
+```jsonc
+// ~/.config/opencode/opencode.json
+{ "plugin": ["/path/to/add-dir-opencode"] }
+
+// ~/.config/opencode/tui.json
+{ "plugin": ["/path/to/add-dir-opencode"] }
+```
 
 </details>
 
 ## Commands
 
-```
-/add-dir /path/to/directory              # Add for this session
-/add-dir /path/to/directory --remember   # Persist across sessions
-/list-dir                                # Show added directories
-/remove-dir /path/to/directory           # Remove a directory
-```
+All commands are interactive TUI dialogs — type the command and select from autocomplete.
+
+| Command | Dialog | Description |
+|---------|--------|-------------|
+| `/add-dir` | Text input + remember checkbox | Add a working directory. Toggle `[x] Remember` with tab to persist across sessions. |
+| `/list-dir` | Alert | Shows all added directories. |
+| `/remove-dir` | Select list + confirm | Pick a directory to remove, then confirm. |
 
 ## How It Works
 
-The plugin uses a layered approach to handle permissions across all sessions, including subagents:
+The plugin has two parts: a **TUI plugin** for the interactive dialogs and a **server plugin** for silent permission handling.
 
-| Layer | When | Scope |
-|-------|------|-------|
-| **Config hook** | Startup | Injects `external_directory: "allow"` rules for persisted dirs into all agents |
-| **Session permission** | `/add-dir` | Sets `external_directory: true` on the current session |
-| **tool.execute.before** | Every file tool | Detects subagent sessions accessing added dirs, grants permission before execution |
-| **Event auto-approve** | Permission popup | Catches any remaining `external_directory` requests and auto-approves via SDK |
+### TUI Plugin
 
-### Context Injection
+Handles all three slash commands via dialogs. Writes persisted directories to `~/.local/share/opencode/add-dir/directories.json` and grants session permissions via the SDK.
 
-If an added directory contains `AGENTS.md`, `CLAUDE.md`, or `.agents/AGENTS.md`, the content is automatically injected into the system prompt.
+### Server Plugin
 
-## Persistence
+Runs in the background — no commands, only hooks:
 
-Directories added with `--remember` are stored in:
+| Hook | What it does |
+|------|-------------|
+| `config` | Injects `external_directory: "allow"` permission rules for persisted dirs at startup |
+| `tool.execute.before` | Auto-grants permissions when subagents access added directories |
+| `event` | Auto-approves any remaining permission popups for added directories |
+| `system.transform` | Injects `AGENTS.md` / `CLAUDE.md` content from added directories into the system prompt |
 
-```
-~/.local/share/opencode/add-dir/directories.json
-```
+### Context Injection
 
-These are loaded at startup and injected into agent permission rules via the config hook.
+If an added directory contains `AGENTS.md`, `CLAUDE.md`, or `.agents/AGENTS.md`, the content is automatically injected into the system prompt.
 
 ## Development
 
 ```bash
 bun install
-bun test           # 33 tests
+bun test           # Run tests
 bun run typecheck  # Type check
 bun run build      # Build npm package
-bun run deploy     # Bundle to ~/.config/opencode/plugins/
+bun run deploy     # Build server + TUI locally
 ```
 
 ### Project Structure
 
 ```
 src/
-├── index.ts        # Entry point (default export)
-├── plugin.ts       # Hooks + commands
-├── state.ts        # Persistence + path utils
-├── validate.ts     # Directory validation
-├── permissions.ts  # Session grants + auto-approve
-├── context.ts      # AGENTS.md injection
-└── types.ts        # Shared type definitions
-```
-
-## Debugging
-
-```bash
-opencode --print-logs 2>debug.log
-grep "\[add-dir\]" debug.log
+├── index.ts          # Server plugin entry
+├── plugin.ts         # Server hooks (permissions, context injection)
+├── tui-plugin.tsx    # TUI plugin (dialogs for add/list/remove)
+├── state.ts          # Persistence, path utils, tui.json auto-config
+├── validate.ts       # Directory validation
+├── permissions.ts    # Session grants + auto-approve
+├── context.ts        # AGENTS.md injection
+└── types.ts          # Shared type definitions
 ```
 
 ## Limitations
 
-- Directories added mid-session (without `--remember`) rely on session-level permissions and the event hook auto-approve. The first access by a subagent may briefly show a permission popup before auto-dismissing.
+- Directories added without "Remember" rely on session-level permissions. The first access by a subagent may briefly show a permission popup before auto-dismissing.
 - The `permission.ask` plugin hook is defined in the OpenCode SDK but [not invoked](https://github.com/sst/opencode/blob/main/packages/opencode/src/permission/index.ts) in the source — this plugin works around it using `tool.execute.before` and event-based auto-approval.
 
 ## License

package/bin/ensure-tui.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+
+const PKG = "opencode-add-dir"
+
+try {
+  const dir = join(
+    process.env.XDG_CONFIG_HOME || join(homedir(), ".config"),
+    "opencode",
+  )
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+
+  let filePath = join(dir, "tui.json")
+  for (const name of ["tui.jsonc", "tui.json"]) {
+    const p = join(dir, name)
+    if (existsSync(p)) { filePath = p; break }
+  }
+
+  let config = {}
+  if (existsSync(filePath)) {
+    const raw = readFileSync(filePath, "utf-8")
+    config = JSON.parse(raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, ""))
+  }
+
+  const plugins = config.plugin || []
+  const has = plugins.some((p) => {
+    const name = Array.isArray(p) ? p[0] : p
+    return name === PKG || (typeof name === "string" && name.startsWith(PKG + "@"))
+  })
+
+  if (!has) {
+    config.plugin = [...plugins, PKG]
+    writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n")
+  }
+} catch {
+  // Non-critical — TUI dialog available after manual setup or restart
+}

package/dist/index.js

@@ -1,15 +1,16 @@
 // src/state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
 import { join } from "path";
 function stateDir() {
   return join(process.env["XDG_DATA_HOME"] || join(process.env["HOME"] || "~", ".local", "share"), "opencode", "add-dir");
 }
+var dirsFile = () => join(stateDir(), "directories.json");
 function expandHome(p) {
   return p.startsWith("~/") ? (process.env["HOME"] || "~") + p.slice(1) : p;
 }
 function loadDirs() {
   const dirs = new Map;
-  const file = join(stateDir(), "directories.json");
+  const file = dirsFile();
   if (!existsSync(file))
     return dirs;
   try {
@@ -18,12 +19,22 @@ function loadDirs() {
   } catch {}
   return dirs;
 }
-function saveDirs(dirs) {
-  const list = [...dirs.values()].filter((d) => d.persist).map((d) => d.path);
-  const dir = stateDir();
-  if (!existsSync(dir))
-    mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "directories.json"), JSON.stringify(list, null, 2));
+var cachedDirs;
+var cachedMtime = 0;
+function freshDirs() {
+  const file = dirsFile();
+  try {
+    const mtime = statSync(file).mtimeMs;
+    if (cachedDirs && mtime === cachedMtime)
+      return cachedDirs;
+    cachedMtime = mtime;
+    cachedDirs = loadDirs();
+    return cachedDirs;
+  } catch {
+    if (!cachedDirs)
+      cachedDirs = new Map;
+    return cachedDirs;
+  }
 }
 function isChildOf(parent, child) {
   return child === parent || child.startsWith(parent + "/");
@@ -113,49 +124,13 @@ function ensureTuiConfig() {
   } catch {}
 }
 
-// src/validate.ts
-import { statSync } from "fs";
-import { resolve } from "path";
-function validateDir(input, worktree, existing) {
-  const trimmed = input.trim();
-  if (!trimmed)
-    return { ok: false, reason: "No directory path provided." };
-  const abs = resolve(expandHome(trimmed));
-  try {
-    if (!statSync(abs).isDirectory())
-      return { ok: false, reason: `${abs} is not a directory.` };
-  } catch (e) {
-    const code = e.code;
-    if (code && ["ENOENT", "ENOTDIR", "EACCES", "EPERM"].includes(code))
-      return { ok: false, reason: `Path ${abs} was not found.` };
-    throw e;
-  }
-  if (isChildOf(worktree, abs))
-    return { ok: false, reason: `${abs} is already within the project directory ${worktree}.` };
-  for (const dir of existing)
-    if (isChildOf(dir, abs))
-      return { ok: false, reason: `${abs} is already accessible within ${dir}.` };
-  return { ok: true, absolutePath: abs };
-}
-
 // src/permissions.ts
-import { join as join2, resolve as resolve2 } from "path";
+import { join as join2, resolve } from "path";
 var FILE_TOOLS = new Set(["read", "write", "edit", "apply_patch", "multiedit", "glob", "grep", "list", "bash"]);
 var grantedSessions = new Set;
 function permissionGlob(dirPath) {
   return join2(dirPath, "*");
 }
-function sendPrompt(sdk, sessionID, text, tools) {
-  const body = { noReply: true, ...tools && { tools }, parts: [{ type: "text", text }] };
-  return sdk.session.promptAsync({ path: { id: sessionID }, body })?.then?.(() => {})?.catch?.(() => {}) ?? Promise.resolve();
-}
-function notify(sdk, sessionID, text) {
-  sendPrompt(sdk, sessionID, text);
-}
-function grantSessionAsync(sdk, sessionID, text) {
-  grantedSessions.add(sessionID);
-  sendPrompt(sdk, sessionID, text, { external_directory: true });
-}
 async function grantSession(sdk, sessionID, text) {
   if (grantedSessions.has(sessionID))
     return;
@@ -167,7 +142,7 @@ function shouldGrantBeforeTool(dirs, tool, args) {
   if (!dirs.size || !FILE_TOOLS.has(tool))
     return false;
   const p = extractPath(tool, args);
-  return !!p && matchesDirs(dirs, resolve2(expandHome(p)));
+  return !!p && matchesDirs(dirs, resolve(expandHome(p)));
 }
 async function autoApprovePermission(sdk, props, dirs) {
   if (props.permission !== "external_directory")
@@ -214,61 +189,12 @@ ${content}`);
 }
 
 // src/plugin.ts
-var SENTINEL = Object.assign(new Error("__ADD_DIR_HANDLED__"), { stack: "" });
-var AddDirPlugin = async ({ client, worktree, directory }) => {
-  const root = worktree || directory;
-  const dirs = loadDirs();
+ensureTuiConfig();
+var AddDirPlugin = async ({ client }) => {
   const sdk = client;
-  ensureTuiConfig();
-  function add(dirPath, persist) {
-    const result = validateDir(dirPath, root, [...dirs.values()].map((d) => d.path));
-    if (!result.ok)
-      return { ok: false, message: result.reason };
-    dirs.set(result.absolutePath, { path: result.absolutePath, persist });
-    if (persist)
-      saveDirs(dirs);
-    const label = persist ? "persistent" : "session";
-    return { ok: true, message: `Added ${result.absolutePath} as a working directory (${label}).` };
-  }
-  function remove(path) {
-    if (!path?.trim())
-      return "Usage: /remove-dir <path>";
-    if (!dirs.has(path))
-      return `${path} is not in the directory list.`;
-    dirs.delete(path);
-    saveDirs(dirs);
-    return `Removed ${path} from working directories.`;
-  }
-  function list() {
-    if (!dirs.size)
-      return "No additional directories added.";
-    return [...dirs.values()].map((d) => `${d.path} (${d.persist ? "persistent" : "session"})`).join(`
-`);
-  }
-  function handleAdd(args, sessionID) {
-    const tokens = args.trim().split(/\s+/);
-    const flags = new Set(tokens.filter((t) => t.startsWith("--")));
-    const pos = tokens.filter((t) => !t.startsWith("--"));
-    if (!pos[0])
-      return notify(sdk, sessionID, "Usage: /add-dir <path> [--remember]");
-    const result = add(pos[0], flags.has("--remember"));
-    if (result.ok)
-      grantSessionAsync(sdk, sessionID, result.message);
-    else
-      notify(sdk, sessionID, result.message);
-  }
-  const commands = {
-    "add-dir": (args, sid) => handleAdd(args, sid),
-    "list-dir": (_, sid) => notify(sdk, sid, list()),
-    "remove-dir": (args, sid) => notify(sdk, sid, remove(args))
-  };
   return {
     config: async (cfg) => {
-      cfg.command ??= {};
-      const cmd = cfg.command;
-      cmd["add-dir"] = { template: "/add-dir", description: "Add a working directory" };
-      cmd["list-dir"] = { template: "/list-dir", description: "List added working directories" };
-      cmd["remove-dir"] = { template: "/remove-dir", description: "Remove a working directory" };
+      const dirs = freshDirs();
       if (!dirs.size)
         return;
       const perm = cfg.permission ??= {};
@@ -276,23 +202,20 @@ var AddDirPlugin = async ({ client, worktree, directory }) => {
       for (const entry of dirs.values())
         extDir[permissionGlob(entry.path)] = "allow";
     },
-    "command.execute.before": async (input) => {
-      const handler = commands[input.command];
-      if (!handler)
-        return;
-      handler(input.arguments || "", input.sessionID);
-      throw SENTINEL;
-    },
     "tool.execute.before": async (input, output) => {
+      const dirs = freshDirs();
       if (shouldGrantBeforeTool(dirs, input.tool, output.args))
         await grantSession(sdk, input.sessionID, "Directory access granted by add-dir plugin.");
     },
     event: async ({ event }) => {
       const e = event;
-      if (e.type === "permission.asked" && e.properties)
+      if (e.type === "permission.asked" && e.properties) {
+        const dirs = freshDirs();
         await autoApprovePermission(sdk, e.properties, dirs);
+      }
     },
     "experimental.chat.system.transform": async (_input, output) => {
+      const dirs = freshDirs();
       output.system.push(...collectAgentContext(dirs));
     }
   };

package/dist/permissions.d.ts

@@ -1,8 +1,7 @@
 import type { DirEntry } from "./state.js";
 import type { SDK, PermissionEvent, ToolArgs } from "./types.js";
 export declare function permissionGlob(dirPath: string): string;
-export declare function notify(sdk: SDK, sessionID: string, text: string): void;
-export declare function grantSessionAsync(sdk: SDK, sessionID: string, text: string): void;
 export declare function grantSession(sdk: SDK, sessionID: string, text: string): Promise<void>;
 export declare function shouldGrantBeforeTool(dirs: Map<string, DirEntry>, tool: string, args: ToolArgs): boolean;
 export declare function autoApprovePermission(sdk: SDK, props: PermissionEvent, dirs: Map<string, DirEntry>): Promise<void>;
+export declare function extractPath(tool: string, args: ToolArgs): string;

package/dist/state.d.ts

@@ -3,8 +3,8 @@ export interface DirEntry {
     persist: boolean;
 }
 export declare function expandHome(p: string): string;
-export declare function loadDirs(): Map<string, DirEntry>;
-export declare function saveDirs(dirs: Map<string, DirEntry>): void;
+export declare function freshDirs(): Map<string, DirEntry>;
+export declare function invalidateCache(): void;
 export declare function isChildOf(parent: string, child: string): boolean;
 export declare function matchesDirs(dirs: Map<string, DirEntry>, filepath: string): boolean;
 export declare function ensureTuiConfig(): void;

package/dist/tui-plugin.d.ts

@@ -1,5 +1,6 @@
-import type { TuiPluginModule } from "@opencode-ai/plugin/tui";
-declare const plugin: TuiPluginModule & {
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
     id: string;
+    tui: TuiPlugin;
 };
-export default plugin;
+export default _default;

package/dist/tui.tsx

@@ -1,110 +1,158 @@
 import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { useKeyboard } from "@opentui/solid"
 import { createSignal } from "solid-js"
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs"
+import { join, resolve } from "path"
 
-const PLUGIN_ID = "opencode-add-dir"
-const COMMAND_NAME = "add-dir"
+const ID = "opencode-add-dir"
+const DIRS_FILE = () => join(process.env["XDG_DATA_HOME"] || join(process.env["HOME"] || "~", ".local", "share"), "opencode", "add-dir", "directories.json")
 
-function activeSessionID(api: TuiPluginApi): string | undefined {
-  const route = api.route.current
-  if (route.name !== "session" || !route.params) return
-  return route.params.sessionID as string
+function readDirs(): string[] {
+  try { return JSON.parse(readFileSync(DIRS_FILE(), "utf-8")) } catch { return [] }
 }
 
-async function ensureSession(api: TuiPluginApi): Promise<string | undefined> {
-  const existing = activeSessionID(api)
-  if (existing) return existing
+function writeDirs(dirs: string[]) {
+  const dir = join(DIRS_FILE(), "..")
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  writeFileSync(DIRS_FILE(), JSON.stringify(dirs, null, 2))
+}
+
+function resolvePath(input: string) {
+  const p = input.trim()
+  return resolve(p.startsWith("~/") ? (process.env["HOME"] || "~") + p.slice(1) : p)
+}
+
+function validate(input: string): string | undefined {
+  if (!input.trim()) return "No directory path provided."
+  const abs = resolvePath(input)
+  try { if (!statSync(abs).isDirectory()) return `${abs} is not a directory.` }
+  catch { return `Path ${abs} was not found.` }
+  if (readDirs().includes(abs)) return `${abs} is already added.`
+}
+
+function sessionID(api: TuiPluginApi): string | undefined {
+  const r = api.route.current
+  return r.name === "session" && r.params ? r.params.sessionID as string : undefined
+}
 
+async function withSession(api: TuiPluginApi): Promise<string | undefined> {
+  const id = sessionID(api)
+  if (id) return id
   const res = await api.client.session.create({})
   if (res.error) return
-
   api.route.navigate("session", { sessionID: res.data.id })
   return res.data.id
 }
 
-async function executeAddDir(api: TuiPluginApi, dirPath: string) {
-  const sessionID = await ensureSession(api)
-  if (!sessionID) {
-    api.ui.toast({ variant: "error", message: "Failed to create session" })
-    return
-  }
-
-  // The server plugin intercepts via command.execute.before, handles the logic,
-  // sends feedback through the session event stream, then throws SENTINEL to
-  // prevent the command template from reaching the LLM. This rejection is expected.
-  api.client.session.command({
-    sessionID,
-    command: COMMAND_NAME,
-    arguments: dirPath,
+type PromptAsyncFn = (params: {
+  sessionID: string
+  parts: { type: "text"; text: string }[]
+  noReply: boolean
+  tools: Record<string, boolean>
+}) => Promise<unknown>
+
+async function grant(api: TuiPluginApi, sid: string, msg: string) {
+  const promptAsync = (api.client.session as unknown as { promptAsync: PromptAsyncFn }).promptAsync
+  await promptAsync({
+    sessionID: sid, parts: [{ type: "text", text: msg }], noReply: true, tools: { external_directory: true },
   }).catch(() => {})
 }
 
 function AddDirDialog(props: { api: TuiPluginApi }) {
   const [busy, setBusy] = createSignal(false)
+  const [remember, setRemember] = createSignal(false)
+  const { api } = props
 
-  async function handleConfirm(value: string) {
-    const dirPath = value.trim()
-    if (!dirPath) {
-      props.api.ui.toast({ variant: "error", message: "Please enter a directory path" })
-      return
-    }
-
-    setBusy(true)
-    try {
-      await executeAddDir(props.api, dirPath)
-      props.api.ui.dialog.clear()
-    } finally {
-      setBusy(false)
-    }
-  }
+  useKeyboard((e) => {
+    if (e.name !== "tab" || busy()) return
+    e.preventDefault(); e.stopPropagation()
+    setRemember((v) => !v)
+  })
 
   return (
-    <props.api.ui.DialogPrompt
+    <api.ui.DialogPrompt
       title="Add directory"
       placeholder="/path/to/directory"
       busy={busy()}
       busyText="Adding directory..."
       description={() => (
-        <box gap={0}>
-          <text fg={props.api.theme.current.textMuted}>
-            To get the full path of a project:
-          </text>
-          <text fg={props.api.theme.current.textMuted}>
-            {" "}1. Move to the project in your terminal
-          </text>
-          <text fg={props.api.theme.current.textMuted}>
-            {" "}2. Run "pwd" and copy the output
-          </text>
-          <text fg={props.api.theme.current.textMuted}>
-            {" "}3. Paste below
-          </text>
+        <box gap={1}>
+          <box gap={0}>
+            <text fg={api.theme.current.textMuted}>To get the full path of a project:</text>
+            <text fg={api.theme.current.textMuted}> 1. Move to the project in your terminal</text>
+            <text fg={api.theme.current.textMuted}> 2. Run "pwd" and copy the output</text>
+            <text fg={api.theme.current.textMuted}> 3. Paste below</text>
+          </box>
+          <box flexDirection="row" gap={1}>
+            <text fg={remember() ? api.theme.current.text : api.theme.current.textMuted}>
+              {remember() ? "[x]" : "[ ]"} Remember across sessions
+            </text>
+            <text fg={api.theme.current.textMuted}>(tab toggle)</text>
+          </box>
         </box>
       )}
-      onConfirm={handleConfirm}
-      onCancel={() => props.api.ui.dialog.clear()}
+      onConfirm={async (value) => {
+        const err = validate(value)
+        if (err) return api.ui.toast({ variant: "error", message: err })
+
+        setBusy(true)
+        try {
+          const sid = await withSession(api)
+          if (!sid) return api.ui.toast({ variant: "error", message: "Failed to create session" })
+          const abs = resolvePath(value)
+          if (remember()) { const d = readDirs(); if (!d.includes(abs)) writeDirs([...d, abs]) }
+          await grant(api, sid, `Added ${abs} as a working directory (${remember() ? "persistent" : "session"}).`)
+          api.ui.dialog.clear()
+        } finally { setBusy(false) }
+      }}
+      onCancel={() => api.ui.dialog.clear()}
     />
   )
 }
 
-function showDialog(api: TuiPluginApi) {
-  api.ui.dialog.replace(() => <AddDirDialog api={api} />)
+function listDirs(api: TuiPluginApi) {
+  const dirs = readDirs()
+  if (!dirs.length) return api.ui.toast({ variant: "info", message: "No directories added." })
+  api.ui.dialog.replace(() => (
+    <api.ui.DialogAlert
+      title={`Directories (${dirs.length})`}
+      message={dirs.join("\n")}
+      onConfirm={() => api.ui.dialog.clear()}
+    />
+  ))
+}
+
+function removeDir(api: TuiPluginApi) {
+  const dirs = readDirs()
+  if (!dirs.length) return api.ui.toast({ variant: "info", message: "No directories to remove." })
+  api.ui.dialog.replace(() => (
+    <api.ui.DialogSelect
+      title="Remove directory"
+      options={dirs.map((d) => ({ title: d, value: d }))}
+      onSelect={(opt) => {
+        api.ui.dialog.replace(() => (
+          <api.ui.DialogConfirm
+            title="Remove directory"
+            message={`Remove ${opt.value}?`}
+            onConfirm={() => {
+              writeDirs(readDirs().filter((d) => d !== opt.value))
+              api.ui.toast({ variant: "success", message: `Removed ${opt.value}` })
+              api.ui.dialog.clear()
+            }}
+            onCancel={() => removeDir(api)}
+          />
+        ))
+      }}
+    />
+  ))
 }
 
 const tui: TuiPlugin = async (api) => {
   api.command.register(() => [
-    {
-      title: "Add directory",
-      value: "add-dir.dialog",
-      description: "Add a working directory to the session",
-      category: "Directories",
-      slash: { name: COMMAND_NAME },
-      onSelect: () => showDialog(api),
-    },
+    { title: "Add directory", value: "add-dir", description: "Add a working directory", category: "Directories", slash: { name: "add-dir" }, onSelect: () => api.ui.dialog.replace(() => <AddDirDialog api={api} />) },
+    { title: "List directories", value: "list-dir", description: "Show working directories", category: "Directories", slash: { name: "list-dir" }, onSelect: () => listDirs(api) },
+    { title: "Remove directory", value: "remove-dir", description: "Remove a working directory", category: "Directories", slash: { name: "remove-dir" }, onSelect: () => removeDir(api) },
   ])
 }
 
-const plugin: TuiPluginModule & { id: string } = {
-  id: PLUGIN_ID,
-  tui,
-}
-
-export default plugin
+export default { id: ID, tui } satisfies TuiPluginModule & { id: string }

package/dist/types.d.ts

@@ -8,9 +8,6 @@ export interface PromptBody {
         text: string;
     }>;
 }
-export interface PermissionReplyBody {
-    response: "once" | "always" | "reject";
-}
 export interface PermissionEvent {
     id: string;
     sessionID: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-add-dir",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Add working directories to your OpenCode session with auto-approved permissions",
   "author": "Cristian Fonseca <cfonsecacomas@gmail.com>",
   "type": "module",
@@ -27,7 +27,8 @@
   },
   "files": [
     "dist/",
-    "bin/",
+    "bin/ensure-tui.mjs",
+    "bin/setup.mjs",
     "README.md",
     "LICENSE"
   ],
@@ -35,6 +36,7 @@
     "build": "bun run build:server && bun run build:tui && bun x tsc --emitDeclarationOnly",
     "build:server": "bun build ./src/index.ts --outdir ./dist --target node --format esm --external @opencode-ai/plugin",
     "build:tui": "cp ./src/tui-plugin.tsx ./dist/tui.tsx",
+    "postinstall": "node ./bin/ensure-tui.mjs",
     "deploy": "bun run build:server && bun run build:tui",
     "test": "bun test",
     "typecheck": "bun x tsc --noEmit",

package/dist/validate.d.ts

@@ -1,8 +0,0 @@
-export type Result = {
-    ok: true;
-    absolutePath: string;
-} | {
-    ok: false;
-    reason: string;
-};
-export declare function validateDir(input: string, worktree: string, existing: string[]): Result;