@iinm/plain-agent 1.10.22 → 1.10.24

package/README.md

@@ -1,17 +1,129 @@
 # Plain Agent
 
-A lightweight coding agent for the terminal.
+A lightweight terminal-based coding agent focused on safety and low token cost
 
-- **Multi-provider** — Use Claude, GPT, Gemini, or any OpenAI-compatible model via direct APIs or through Bedrock, Vertex AI, or Azure.
-- **Fine-grained auto-approval** — Auto-approve tool calls by matching tool names and inputs against configurable patterns, while validating string inputs as paths for safety.
-- **Sandboxed execution** — Run commands in a Docker container with filesystem and network isolation.
-- **Supports Claude Code resources** — Use Claude Code plugins, commands, subagents, and skills from `.claude/`.
-- **Zero external dependencies** — Built using only Node.js standard libraries.
+## Design
 
-## Limitations
+### Multi-provider support
 
-- **Path validation only covers tool arguments** — It blocks paths outside the working directory, directory traversal (`..`), symlinks that escape the project, and git-ignored files. However, it only applies to paths explicitly passed as tool-use arguments, so it cannot control file access inside arbitrary scripts. Always use sandboxed execution when running arbitrary scripts.
-- **Sequential subagent execution** — Subagents run one at a time rather than in parallel. The trade-off is that every step is streamed to your terminal, so you can follow exactly what each subagent is doing.
+Supports Claude, OpenAI, Gemini, and any OpenAI-compatible provider. Bedrock, Vertex AI, and Azure are also supported for teams working in environments restricted to managed cloud providers.
+
+### Auto-approval
+
+Configure what the agent can do automatically using a small DSL with regex matching. Below is an excerpt from the [default config](https://github.com/iinm/plain-agent/blob/main/config/config.predefined.json).
+
+```js
+{
+  "autoApproval": {
+    // What to do when no pattern matches: ask - prompt the user, deny - reject automatically
+    "defaultAction": "ask",
+
+    // Patterns are evaluated top-to-bottom; first match wins
+    "patterns": [
+      // fd example:
+      // Ask for approval when risky flags like --exec or --no-ignore are present
+      {
+        "toolName": "exec_command",
+        "input": {
+          "command": "fd",
+          "args": { "$has": { "$regex": "^(--unrestricted|--no-ignore|--exec|--exec-batch|--follow|-[^-]*[uIxXL])" } }
+        },
+        "action": "ask"
+      },
+      // Allow all other fd calls
+      {
+        "toolName": "exec_command",
+        "input": { "command": "fd" },
+        "action": "allow"
+      },
+
+      // GitHub CLI example:
+      // Allow read access to PRs and issues
+      {
+        "toolName": "exec_command",
+        "input": {
+          "command": "gh",
+          "args": ["api", "--method", "GET", { "$regex": "^repos/[^/]+/[^/]+/(pulls|issues)/" }]
+        },
+        "action": "allow"
+      },
+      // Require --method to be explicit, so GET calls can be safely auto-approved
+      {
+        "toolName": "exec_command",
+        "input": { "command": "gh", "args": ["api", "--method"] },
+        "action": "ask"
+      },
+      {
+        "toolName": "exec_command",
+        "input": { "command": "gh", "args": ["api"] },
+        "action": "deny",
+        "reason": "--method must be specified"
+      }
+    ]
+  }
+}
+```
+
+### Path Validation
+
+String values in tool inputs are treated as file paths and validated against these rules. This takes precedence over `autoApproval` — even if a pattern marks an action as `allow`, a validation failure falls back to `defaultAction`.
+
+- The path must be under the working directory or a path listed in `autoApproval.allowedPaths`
+- No directory traversal (`..` is not allowed)
+- The file must be tracked by Git (not ignored)
+
+**Note**: validation only applies when the agent explicitly passes file paths to tools. It cannot catch file access inside scripts the agent writes — something like `bash -c "rm -rf /"` is beyond its reach. Always use a sandbox when allowing arbitrary script execution.
+
+### Sandbox
+
+The agent can run arbitrary commands via `exec_command` and `tmux_command`. You can configure a wrapper command that intercepts both.
+A Docker-based wrapper called `plain-sandbox` is included, but the interface is designed to work with other tools as well, such as [Anthropic Sandbox Runtime (srt)](https://github.com/anthropic-experimental/sandbox-runtime).
+
+```js
+{
+  // Sandbox environment for the exec_command and tmux_command tools
+  "sandbox": {
+    // Commands are wrapped and executed with this command
+    "command": "plain-sandbox",
+    "args": ["--allow-write", "--skip-build", "--keep-alive", "30"],
+    // separator is inserted between sandbox flags and the user command to prevent bypasses
+    "separator": "--",
+
+    "rules": [
+      // Run specific commands outside the sandbox
+      {
+        "pattern": {
+          "command": { "$regex": "^(gh|docker)$" }
+        },
+        "mode": "unsandboxed"
+      },
+      // Run commands in the sandbox with network access
+      {
+        "pattern": {
+          "command": "npm",
+          "args": [{ "$regex": "^(install|ci)$" }]
+        },
+        "mode": "sandbox",
+        "additionalArgs": ["--allow-net", "registry.npmjs.org"]
+      }
+    ]
+  }
+}
+```
+
+### Token Efficiency
+
+A few design choices keep token usage low:
+
+- Minimal system prompt — the [system prompt](https://github.com/iinm/plain-agent/blob/main/src/prompt.mjs) contains only what the agent needs to function. 
+- Output truncation — when a command or MCP tool produces large output, it is truncated and saved to a file. The agent can then read only the relevant parts.
+- (Experimental) [Hashline-based](https://blog.can.ac/2026/02/12/the-harness-problem/) patch_file tool.
+
+### Claude Code Compatibility
+
+Claude Code has a plugin ecosystem and is widely used across teams. plain-agent supports `.claude/` commands, subagents, and skills so you can share project skills with Claude Code users. Plugins can also be installed.
+
+**Limitation:** Subagents run sequentially, not in parallel. The upside is that their activity is fully observable and they don't spike token usage. They also inherit the main context rather than starting fresh — a simplification chosen for ease of implementation, which also avoids redundant file reads and reduces the chance of losing context between handoffs.
 
 ## Requirements
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.10.22",
-  "description": "A lightweight coding agent for the terminal.",
+  "version": "1.10.24",
+  "description": "A lightweight terminal-based coding agent focused on safety and low token cost",
   "license": "MIT",
   "type": "module",
   "repository": {

package/sandbox/bin/plain-sandbox

@@ -18,8 +18,8 @@ Usage: $SCRIPT_NAME [--dockerfile FILE]
            [--env-file FILE]
            [--allow-write] [--allow-net [DESTINATIONS|--]]
            [--volume [NAME:]PATH]
-           [--mount-writable HOST_DIR:CONTAINER_DIR]
-           [--mount-readonly HOST_DIR:CONTAINER_DIR]
+           [--mount-writable HOST_PATH[:CONTAINER_PATH]]
+           [--mount-readonly HOST_PATH[:CONTAINER_PATH]]
            [--publish [HOST_ADDRESS:]HOST_PORT:CONTAINER_PORT]
            [--tty]
            [--no-cache]
@@ -50,11 +50,19 @@ Options:
                             inside the container.
                             If NAME is not given, the volume name is generated.
 
-  --mount-readonly HOST_DIR:CONTAINER_DIR
+  --mount-readonly HOST_PATH[:CONTAINER_PATH]
                             Mount a host file or directory to a container path as read-only.
+                            If CONTAINER_PATH is omitted, the resolved absolute host path is used.
+                            Relative HOST_PATH is resolved from the current working directory.
+                            Relative CONTAINER_PATH is resolved from the working directory
+                            inside the container.
 
-  --mount-writable HOST_DIR:CONTAINER_DIR
+  --mount-writable HOST_PATH[:CONTAINER_PATH]
                             Mount a host file or directory to a container path as writable.
+                            If CONTAINER_PATH is omitted, the resolved absolute host path is used.
+                            Relative HOST_PATH is resolved from the current working directory.
+                            Relative CONTAINER_PATH is resolved from the working directory
+                            inside the container.
 
   --publish [HOST_ADDRESS:]HOST_PORT:CONTAINER_PORT
                             Publish container port(s) to the host.
@@ -384,12 +392,22 @@ main() {
     for mount in "${readonly_mounts[@]}"; do
       local host_path
       local container_path
-      IFS=':' read -r host_path container_path <<< "$mount"
+      if grep -qE ':' <<< "$mount"; then
+        IFS=':' read -r host_path container_path <<< "$mount"
+      else
+        host_path="$mount"
+        container_path=""
+      fi
       local host_abs_path="$host_path"
       if ! grep -qE '^/' <<< "$host_abs_path"; then
         # shellcheck disable=SC2001
         host_abs_path=$(readlink -f "$(sed "s,~/,$HOME/," <<< "$host_abs_path")")
       fi
+      if test -z "$container_path"; then
+        container_path="$host_abs_path"
+      elif ! grep -qE '^/' <<< "$container_path"; then
+        container_path="${container_workdir}/${container_path}"
+      fi
       docker_run_opts+=(--mount "type=bind,source=${host_abs_path},target=${container_path},readonly,consistency=delegated")
     done
   fi
@@ -398,12 +416,22 @@ main() {
     for mount in "${writable_mounts[@]}"; do
       local host_path
       local container_path
-      IFS=':' read -r host_path container_path <<< "$mount"
+      if grep -qE ':' <<< "$mount"; then
+        IFS=':' read -r host_path container_path <<< "$mount"
+      else
+        host_path="$mount"
+        container_path=""
+      fi
       local host_abs_path="$host_path"
       if ! grep -qE '^/' <<< "$host_abs_path"; then
         # shellcheck disable=SC2001
         host_abs_path=$(readlink -f "$(sed "s,~/,$HOME/," <<< "$host_abs_path")")
       fi
+      if test -z "$container_path"; then
+        container_path="$host_abs_path"
+      elif ! grep -qE '^/' <<< "$container_path"; then
+        container_path="${container_workdir}/${container_path}"
+      fi
       docker_run_opts+=(--mount "type=bind,source=${host_abs_path},target=${container_path},consistency=delegated")
     done
   fi

package/src/prompt.mjs

@@ -49,38 +49,25 @@ Respond in the user's language.
 
 # Memory Files
 
-Memory files preserve task state so work can be resumed after a context reset.
+Memory files preserve state to resume work after context resets.
 
-- Create/Update memory files when creating/updating a plan, completing milestones, encountering issues, or making decisions. Skip memory files for tasks that can be completed in a few steps.
-- Ensure self-containment: Write as if the reader has no prior knowledge of the conversation.
+- Create/Update memory files when creating/updating a plan, completing milestones, encountering issues, or making decisions.
+- Skip memory files for tasks that can be completed in a few steps.
 - Write the memory content in the user's language.
 
 Memory files should include:
 - Task overview: What the task is, why it's being done, requirements and constraints
-- References: AGENTS.md, skills, relevant documentation, source files, and commands
-- Progress tracking: Completed milestones with evidence, current status, and next steps
-- Decision records: Key decisions, alternatives considered, and rationale
+- References: AGENTS.md, documentation, source files, commands
+- Progress tracking: Completed milestones with results, current status, and next steps
+- Decision records: Key decisions, alternatives considered, and reason
 
 # Tools
 
-Call multiple tools at once when they don't depend on each other's results.
-
-## patch_file
-
-Always read the target lines with \`read_file\` first to verify line numbers and their 2-char hashes before calling \`patch_file\`.
-
-## exec_command
-
+- Run independent tools in parallel.
+- Verify line numbers and hashes with read_file before calling patch_file.
 - Use relative paths for files inside the working directory, absolute paths for files outside.
 - Use ${projectMetadataDir}/tmp/ for temporary files.
 
-Examples:
-- List directories or find files: fd [".", "./", "--max-depth", "3", "--type", "d", "--hidden"]
-- Search for strings: rg ["--heading", "--line-number", "pattern", "./"]
-- Manage GitHub issues and PRs:
-  Get PR details: gh ["pr", "view", "123", "--json", "title,body,url"]
-  Get PR comment: gh ["api", "--method", "GET", "repos/<owner>/<repo>/pulls/comments/<id>", "--jq", "{user: .user.login, path: .path, line: .line, body: .body}"]
-
 # Project Rules and Skills
  
 Discover and apply project-specific rules and reusable skills.
@@ -99,12 +86,12 @@ ${skillDescriptions}
 
 # Environment
 
+- Session id: ${sessionId}
+- Memory file path: ${projectMetadataDir}/memory/${sessionId}--<kebab-case-title>.md
 - User name: ${username}
 - Your model name: ${modelName}
 - Current working directory: ${workingDir}
 - Today's date: ${today}
-- Session id: ${sessionId}
-- Memory file path: ${projectMetadataDir}/memory/${sessionId}--<kebab-case-title>.md
 
 Available subagents:
 ${agentRoleDescriptions}

package/src/tools/execCommand.mjs

@@ -20,7 +20,15 @@ export function createExecCommandTool(config) {
   return {
     def: {
       name: "exec_command",
-      description: "Run a command without shell interpretation.",
+      description: `Run a command without shell interpretation.
+
+Examples:
+- List directories or find files: fd [".", "./", "--max-depth", "3", "--type", "d", "--hidden"]
+- Search for strings: rg ["--heading", "--line-number", "pattern", "./"]
+- Manage GitHub issues and PRs:
+  Get PR details: gh ["pr", "view", "123", "--json", "title,body,url"]
+  Get PR comment: gh ["api", "--method", "GET", "repos/<owner>/<repo>/pulls/comments/<id>", "--jq", "{user: .user.login, path: .path, line: .line, body: .body}"]
+      `.trim(),
       inputSchema: {
         type: "object",
         properties: {
@@ -29,9 +37,7 @@ export function createExecCommandTool(config) {
             type: "string",
           },
           args: {
-            // Gemini 3 flashが command: rg, args: [rg, ...] のようにargsにコマンドを含めることがある
-            description:
-              "Array of arguments to pass to the command. Do not include the command name itself in this array.",
+            description: "Array of arguments to pass to the command.",
             type: "array",
             items: {
               type: "string",