opencode-add-dir 1.2.1 → 1.3.1

package/README.md

@@ -31,7 +31,6 @@ Automatically adds the plugin to your global `opencode.json`.
 <summary>Alternative: local file</summary>
 
 ```bash
-# Clone and build
 git clone https://github.com/kuzeofficial/add-dir-opencode.git
 cd add-dir-opencode
 bun install && bun run deploy
@@ -41,27 +40,15 @@ Bundles to `~/.config/opencode/plugins/add-dir.js`.
 
 </details>
 
-## Usage
-
-### Slash Command
+## Commands
 
 ```
-/add-dir /path/to/directory              # Session only
+/add-dir /path/to/directory              # Add for this session
 /add-dir /path/to/directory --remember   # Persist across sessions
-/add-dir list                            # Show added directories
-/add-dir remove /path/to/directory       # Remove a directory
+/list-dir                                # Show added directories
+/remove-dir /path/to/directory           # Remove a directory
 ```
 
-### LLM Tools
-
-The agent can also call these tools directly:
-
-| Tool | Description |
-|------|-------------|
-| `add_dir` | Add a directory (with optional `remember` flag) |
-| `list_dirs` | List all added directories |
-| `remove_dir` | Remove a directory |
-
 ## How It Works
 
 The plugin uses a layered approach to handle permissions across all sessions, including subagents:
@@ -69,13 +56,13 @@ The plugin uses a layered approach to handle permissions across all sessions, in
 | 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 via `tools` field |
+| **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 |
 
-### AGENTS.md Injection
+### Context Injection
 
-If an added directory contains `AGENTS.md`, `CLAUDE.md`, or `.agents/AGENTS.md`, the content is automatically injected into the system prompt via `experimental.chat.system.transform`.
+If an added directory contains `AGENTS.md`, `CLAUDE.md`, or `.agents/AGENTS.md`, the content is automatically injected into the system prompt.
 
 ## Persistence
 
@@ -91,7 +78,7 @@ These are loaded at startup and injected into agent permission rules via the con
 
 ```bash
 bun install
-bun test           # 17 tests
+bun test           # 33 tests
 bun run typecheck  # Type check
 bun run build      # Build npm package
 bun run deploy     # Bundle to ~/.config/opencode/plugins/
@@ -102,24 +89,18 @@ bun run deploy     # Bundle to ~/.config/opencode/plugins/
 ```
 src/
 ├── index.ts        # Entry point (default export)
-├── plugin.ts       # Hooks + tools
-├── state.ts        # Persistence
+├── plugin.ts       # Hooks + commands
+├── state.ts        # Persistence + path utils
 ├── validate.ts     # Directory validation
 ├── permissions.ts  # Session grants + auto-approve
-└── context.ts      # AGENTS.md injection
+├── context.ts      # AGENTS.md injection
+└── types.ts        # Shared type definitions
 ```
 
 ## Debugging
 
-Run OpenCode with logs:
-
 ```bash
 opencode --print-logs 2>debug.log
-```
-
-Filter plugin logs:
-
-```bash
 grep "\[add-dir\]" debug.log
 ```
 

package/dist/index.js

@@ -1,12 +1,12 @@
-// src/plugin.ts
-import { tool } from "@opencode-ai/plugin";
-
 // src/state.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 function stateDir() {
   return join(process.env["XDG_DATA_HOME"] || join(process.env["HOME"] || "~", ".local", "share"), "opencode", "add-dir");
 }
+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");
@@ -39,9 +39,6 @@ function matchesDirs(dirs, filepath) {
 // src/validate.ts
 import { statSync } from "fs";
 import { resolve } from "path";
-function expandHome(p) {
-  return p.startsWith("~/") ? (process.env["HOME"] || "~") + p.slice(1) : p;
-}
 function validateDir(input, worktree, existing) {
   const trimmed = input.trim();
   if (!trimmed)
@@ -51,7 +48,8 @@ function validateDir(input, worktree, existing) {
     if (!statSync(abs).isDirectory())
       return { ok: false, reason: `${abs} is not a directory.` };
   } catch (e) {
-    if ("ENOENT ENOTDIR EACCES EPERM".includes(e.code))
+    const code = e.code;
+    if (code && ["ENOENT", "ENOTDIR", "EACCES", "EPERM"].includes(code))
       return { ok: false, reason: `Path ${abs} was not found.` };
     throw e;
   }
@@ -67,46 +65,37 @@ function validateDir(input, worktree, existing) {
 import { join as join2, resolve as resolve2 } from "path";
 var FILE_TOOLS = new Set(["read", "write", "edit", "apply_patch", "multiedit", "glob", "grep", "list", "bash"]);
 var grantedSessions = new Set;
-function expandHome2(p) {
-  return p.startsWith("~/") ? (process.env["HOME"] || "~") + p.slice(1) : p;
-}
-function extractPath(tool, args) {
-  if (!args)
-    return "";
-  if (tool === "bash")
-    return args.workdir || args.command || "";
-  return args.filePath || args.path || args.pattern || "";
-}
 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;
   grantedSessions.add(sessionID);
-  await sdk.session.prompt({
-    path: { id: sessionID },
-    body: { noReply: true, tools: { external_directory: true }, parts: [{ type: "text", text }] }
-  }).catch(() => {});
-}
-function grantSessionAsync(sdk, sessionID, text) {
-  setTimeout(() => {
-    sdk.session.promptAsync({
-      path: { id: sessionID },
-      body: { noReply: true, tools: { external_directory: true }, parts: [{ type: "text", text }] }
-    })?.then?.(() => grantedSessions.add(sessionID))?.catch?.(() => {});
-  }, 150);
+  const body = { noReply: true, tools: { external_directory: true }, parts: [{ type: "text", text }] };
+  await sdk.session.prompt({ path: { id: sessionID }, body }).catch(() => {});
 }
 function shouldGrantBeforeTool(dirs, tool, args) {
   if (!dirs.size || !FILE_TOOLS.has(tool))
     return false;
   const p = extractPath(tool, args);
-  return !!p && matchesDirs(dirs, resolve2(expandHome2(p)));
+  return !!p && matchesDirs(dirs, resolve2(expandHome(p)));
 }
 async function autoApprovePermission(sdk, props, dirs) {
   if (props.permission !== "external_directory")
     return;
-  const meta = props.metadata ?? {};
+  const meta = props.metadata;
   const filepath = meta.filepath ?? "";
   const parentDir = meta.parentDir ?? "";
   const patterns = props.patterns ?? [];
@@ -118,9 +107,16 @@ async function autoApprovePermission(sdk, props, dirs) {
     body: { response: "always" }
   }).catch(() => {});
 }
+function extractPath(tool, args) {
+  if (!args)
+    return "";
+  if (tool === "bash")
+    return args.workdir || args.command || "";
+  return args.filePath || args.path || args.pattern || "";
+}
 
 // src/context.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { join as join3 } from "path";
 var CONTEXT_FILES = ["AGENTS.md", "CLAUDE.md", ".agents/AGENTS.md"];
 function collectAgentContext(dirs) {
@@ -128,8 +124,6 @@ function collectAgentContext(dirs) {
   for (const entry of dirs.values()) {
     for (const name of CONTEXT_FILES) {
       const fp = join3(entry.path, name);
-      if (!existsSync2(fp))
-        continue;
       try {
         const content = readFileSync2(fp, "utf-8").trim();
         if (content)
@@ -143,24 +137,28 @@ ${content}`);
 }
 
 // src/plugin.ts
-var SENTINEL = "__ADD_DIR_HANDLED__";
+var SENTINEL = Object.assign(new Error("__ADD_DIR_HANDLED__"), { stack: "" });
+function log(msg, data) {
+  console.error(`[add-dir] ${msg}`, data !== undefined ? JSON.stringify(data) : "");
+}
 var AddDirPlugin = async ({ client, worktree, directory }) => {
   const root = worktree || directory;
   const dirs = loadDirs();
   const sdk = client;
-  function add(dirPath, persist, sessionID) {
+  log("init", { root, persistedDirs: [...dirs.keys()] });
+  function add(dirPath, persist) {
     const result = validateDir(dirPath, root, [...dirs.values()].map((d) => d.path));
     if (!result.ok)
-      return result.reason;
+      return { ok: false, message: result.reason };
     dirs.set(result.absolutePath, { path: result.absolutePath, persist });
     if (persist)
       saveDirs(dirs);
     const label = persist ? "persistent" : "session";
-    const msg = `Added ${result.absolutePath} as a working directory (${label}).`;
-    grantSessionAsync(sdk, sessionID, msg);
-    return msg;
+    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);
@@ -173,73 +171,64 @@ var AddDirPlugin = async ({ client, worktree, directory }) => {
     return [...dirs.values()].map((d) => `${d.path} (${d.persist ? "persistent" : "session"})`).join(`
 `);
   }
-  function handleCommand(args, sessionID) {
+  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] === "list")
-      return list();
-    if (pos[0] === "remove" && pos[1])
-      return remove(pos[1]);
     if (!pos[0])
-      return `Usage: /add-dir <path> [--remember]
-       /add-dir list
-       /add-dir remove <path>`;
-    return add(pos[0], flags.has("--remember"), sessionID);
+      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) => {
+      log("add-dir", { args, sid });
+      handleAdd(args, sid);
+    },
+    "list-dir": (_, sid) => {
+      log("list-dir", { sid });
+      notify(sdk, sid, list());
+    },
+    "remove-dir": (args, sid) => {
+      log("remove-dir", { args, sid });
+      notify(sdk, sid, remove(args));
+    }
+  };
   return {
     config: async (cfg) => {
       cfg.command ??= {};
-      cfg.command["add-dir"] = { template: "/add-dir", description: "Add a working directory for this session" };
+      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" };
       if (!dirs.size)
         return;
-      cfg.permission ??= {};
-      cfg.permission.external_directory ??= {};
+      const perm = cfg.permission ??= {};
+      const extDir = perm.external_directory ??= {};
       for (const entry of dirs.values())
-        cfg.permission.external_directory[permissionGlob(entry.path)] = "allow";
+        extDir[permissionGlob(entry.path)] = "allow";
     },
     "command.execute.before": async (input) => {
-      if (input.command !== "add-dir")
+      const handler = commands[input.command];
+      if (!handler)
         return;
-      handleCommand(input.arguments || "", input.sessionID);
-      throw new Error(SENTINEL);
+      handler(input.arguments || "", input.sessionID);
+      throw SENTINEL;
     },
     "tool.execute.before": async (input, output) => {
       if (shouldGrantBeforeTool(dirs, input.tool, output.args))
         await grantSession(sdk, input.sessionID, "Directory access granted by add-dir plugin.");
     },
     event: async ({ event }) => {
-      if (event.type === "permission.asked" && event.properties)
-        await autoApprovePermission(sdk, event.properties, dirs);
+      const e = event;
+      if (e.type === "permission.asked" && e.properties)
+        await autoApprovePermission(sdk, e.properties, dirs);
     },
-    "experimental.chat.system.transform": async (_, output) => {
+    "experimental.chat.system.transform": async (_input, output) => {
       output.system.push(...collectAgentContext(dirs));
-    },
-    tool: {
-      add_dir: tool({
-        description: "Add an external directory as a working directory. Files in added directories can be read and edited without permission prompts.",
-        args: {
-          path: tool.schema.string().describe("Absolute or relative path to directory"),
-          remember: tool.schema.boolean().optional().describe("Persist across sessions")
-        },
-        async execute(args, ctx) {
-          return add(args.path, args.remember ?? false, ctx.sessionID);
-        }
-      }),
-      list_dirs: tool({
-        description: "List all added working directories.",
-        args: {},
-        async execute() {
-          return list();
-        }
-      }),
-      remove_dir: tool({
-        description: "Remove a previously added working directory.",
-        args: { path: tool.schema.string().describe("Path of directory to remove") },
-        async execute(args) {
-          return remove(args.path);
-        }
-      })
     }
   };
 };

package/dist/permissions.d.ts

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

package/dist/state.d.ts

@@ -2,6 +2,7 @@ export interface DirEntry {
     path: string;
     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 isChildOf(parent: string, child: string): boolean;

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export type SDK = PluginInput["client"];
+export interface PromptBody {
+    noReply: true;
+    tools?: Record<string, boolean>;
+    parts: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+export interface PermissionReplyBody {
+    response: "once" | "always" | "reject";
+}
+export interface PermissionEvent {
+    id: string;
+    sessionID: string;
+    permission: string;
+    patterns: string[];
+    metadata: Record<string, unknown>;
+    always: string[];
+}
+export interface ToolArgs {
+    filePath?: string;
+    path?: string;
+    pattern?: string;
+    workdir?: string;
+    command?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-add-dir",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Add working directories to your OpenCode session with auto-approved permissions",
   "author": "Cristian Fonseca <cfonsecacomas@gmail.com>",
   "type": "module",