@iinm/plain-agent 1.7.24 → 1.8.0

package/README.md

@@ -6,7 +6,7 @@ A lightweight CLI-based coding agent.
 - **Compact system prompt** — Under 3.5 KB, keeping per-request overhead and cost low ([src/prompt.mjs](https://github.com/iinm/plain-agent/blob/main/src/prompt.mjs)).
 - **Fine-grained approval rules** — Auto-approve commands by name, arguments,
   and file paths using regex patterns
-  ([`config.predefined.json#autoApproval`](https://github.com/iinm/plain-agent/blob/main/config/config.predefined.json)).
+  ([config.predefined.json#autoApproval](https://github.com/iinm/plain-agent/blob/main/config/config.predefined.json)).
 - **Path validation** — Restricts access to the working directory.
   Git-ignored and untracked files require explicit approval.
 - **Sandboxed execution** — Run the agent's shell commands inside a Docker

package/config/agents.predefined/sandbox-configurator.md

@@ -2,7 +2,7 @@
 description: Analyzes the project and generates sandbox configuration files (run.sh, setup.sh) tailored to the project's needs.
 ---
 
-You are a sandbox builder. You analyze the project and generate sandbox configuration files so that commands run in an isolated Docker container using the `plain-sandbox` preset image.
+You are a sandbox configurator. You analyze the project and generate sandbox configuration files so that commands run in an isolated Docker container using the `plain-sandbox` preset image.
 
 ## Overview
 
@@ -11,8 +11,6 @@ You create the following files:
 - `.plain-agent/sandbox/run.sh` — Wrapper script for `plain-sandbox` with project-specific options
 - `.plain-agent/setup.sh` — Initial setup script for both sandbox and host
 
-You also show an example `sandbox` config for `.plain-agent/config.json`, but you **never modify** config.json directly.
-
 ## Step 1: Analyze the Project
 
 Before generating anything, analyze the project to determine:

package/config/config.predefined.json

@@ -1050,6 +1050,29 @@
         }
       }
     },
+    {
+      "name": "deepseek-v4-pro",
+      "variant": "fireworks",
+      "platform": {
+        "name": "openai-compatible",
+        "variant": "fireworks"
+      },
+      "model": {
+        "format": "openai-messages",
+        "config": {
+          "model": "accounts/fireworks/models/deepseek-v4-pro"
+        }
+      },
+      "cost": {
+        "currency": "USD",
+        "unit": "1M",
+        "costs": {
+          "prompt_tokens": 1.74,
+          "prompt_tokens_details.cached_tokens": -1.6,
+          "completion_tokens": 3.48
+        }
+      }
+    },
 
     {
       "name": "minimax-m2.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.7.24",
+  "version": "1.8.0",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",
@@ -33,12 +33,6 @@
     "fix": "npx @biomejs/biome check --fix"
   },
   "dependencies": {
-    "@aws-crypto/sha256-js": "^5.2.0",
-    "@aws-sdk/credential-providers": "^3.1030.0",
-    "@cfworker/json-schema": "^4.1.1",
-    "@modelcontextprotocol/client": "^2.0.0-alpha.2",
-    "@smithy/protocol-http": "^5.3.13",
-    "@smithy/signature-v4": "^5.3.13",
     "diff": "^8.0.4",
     "js-yaml": "^4.1.1"
   },
@@ -46,6 +40,6 @@
     "@biomejs/biome": "^2.4.12",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.19.17",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   }
 }

package/src/agent.d.ts

@@ -1,4 +1,6 @@
 import type { EventEmitter } from "node:events";
+import type { AgentRole } from "./context/loadAgentRoles.mjs";
+import type { CostConfig, CostSummary } from "./costTracker.mjs";
 import type {
   CallModel,
   Message,
@@ -8,8 +10,6 @@ import type {
   ProviderTokenUsage,
 } from "./model";
 import type { Tool, ToolUseApprover } from "./tool";
-import type { AgentRole } from "./context/loadAgentRoles.mjs";
-import type { CostSummary, CostConfig } from "./costTracker.mjs";
 
 export type Agent = {
   userEventEmitter: UserEventEmitter;

package/src/config.d.ts

@@ -1,9 +1,9 @@
+import { ClaudeCodePluginRepo } from "./claudeCodePlugin.mjs";
 import { ModelDefinition, PlatformConfig } from "./modelDefinition";
 import { ToolUsePattern } from "./tool";
 import { AskURLToolOptions } from "./tools/askURL.mjs";
 import { AskWebToolOptions } from "./tools/askWeb.mjs";
 import { ExecCommandSanboxConfig } from "./tools/execCommand";
-import { ClaudeCodePluginRepo } from "./claudeCodePlugin.mjs";
 import { VoiceInputConfig } from "./voiceInput.mjs";
 
 export type AppConfig = {

package/src/main.mjs

@@ -16,7 +16,7 @@ import { loadAppConfig } from "./config.mjs";
 import { loadAgentRoles } from "./context/loadAgentRoles.mjs";
 import { loadPrompts } from "./context/loadPrompts.mjs";
 import { AGENT_PROJECT_METADATA_DIR, USER_NAME } from "./env.mjs";
-import { setupMCPServer } from "./mcp.mjs";
+import { setupMCPServer } from "./mcpIntegration.mjs";
 import { createModelCaller } from "./modelCaller.mjs";
 import { createPrompt } from "./prompt.mjs";
 import { createAskURLTool } from "./tools/askURL.mjs";
@@ -164,9 +164,10 @@ if (cliArgs.subcommand.type === "cost") {
   const prompt = createPrompt({
     username: USER_NAME,
     modelName: modelNameWithVariant,
+    workingDir: process.cwd(),
+    today: new Date().toISOString().split("T")[0],
     sessionId,
     tmuxSessionId,
-    workingDir: process.cwd(),
     projectMetadataDir: AGENT_PROJECT_METADATA_DIR,
     agentRoles,
     skills: Array.from(prompts.values()).filter((p) => p.isSkill),

package/src/mcpClient.mjs

@@ -0,0 +1,351 @@
+import { spawn } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
+import { createInterface } from "node:readline";
+
+/**
+ * @typedef {Object} CreateMCPClientOptions
+ * @property {string} command
+ * @property {string[]} [args]
+ * @property {Record<string, string>} [env]
+ * @property {"inherit" | "ignore" | "pipe" | string} [stderr]
+ * @property {string} [protocolVersion]
+ * @property {{ name: string, version: string }} [clientInfo]
+ * @property {Record<string, unknown>} [capabilities]
+ * @property {(method: string, params?: unknown) => void} [onNotification]
+ *   Currently unused by callers, but provided for MCP protocol compliance (e.g. notifications/progress).
+ */
+
+/**
+ * Spawn an MCP server process and return an initialized client.
+ * @param {CreateMCPClientOptions} options
+ * @returns {Promise<MCPClient>}
+ */
+export async function createMCPClient(options) {
+  const transport = new StdioTransport(options.command, options.args, {
+    env: options.env,
+    stderr: options.stderr,
+    onNotification: options.onNotification,
+  });
+
+  const client = new MCPClient(transport);
+  try {
+    await client.initialize({
+      protocolVersion: options.protocolVersion,
+      clientInfo: options.clientInfo,
+      capabilities: options.capabilities,
+    });
+  } catch (err) {
+    await client.close().catch(() => {});
+    throw err;
+  }
+  return client;
+}
+
+/**
+ * MCP protocol client.
+ * Delegates transport concerns to a transport object.
+ */
+export class MCPClient {
+  /** @type {StdioTransport} */
+  #transport;
+  #closed = false;
+
+  /**
+   * @param {StdioTransport} transport
+   */
+  constructor(transport) {
+    this.#transport = transport;
+  }
+
+  /**
+   * @param {Object} [options]
+   * @param {string} [options.protocolVersion]
+   * @param {{ name: string, version: string }} [options.clientInfo]
+   * @param {Record<string, unknown>} [options.capabilities]
+   * @returns {Promise<any>}
+   */
+  async initialize(options = {}) {
+    if (this.#closed) {
+      throw new Error("MCP client is closed");
+    }
+    const result = await this.#transport.request("initialize", {
+      protocolVersion: options.protocolVersion ?? "2025-03-26",
+      capabilities: options.capabilities ?? {},
+      clientInfo: options.clientInfo ?? {
+        name: "unknown",
+        version: "0.0.0",
+      },
+    });
+    this.#transport.notify("notifications/initialized");
+    return result;
+  }
+
+  /**
+   * @returns {Promise<{ tools: Array<{ name: string, description?: string, inputSchema: Record<string, unknown> }> }>}
+   */
+  async listTools() {
+    if (this.#closed) {
+      throw new Error("MCP client is closed");
+    }
+    return this.#transport.request("tools/list", {});
+  }
+
+  /**
+   * @param {{ name: string, arguments?: Record<string, unknown> }} params
+   * @returns {Promise<{ content?: Array<{ type: string, text?: string, data?: string, mimeType?: string }>, isError?: boolean }>}
+   */
+  async callTool(params) {
+    if (this.#closed) {
+      throw new Error("MCP client is closed");
+    }
+    return this.#transport.request("tools/call", params);
+  }
+
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    await this.#transport.close();
+  }
+}
+
+/**
+ * @typedef {Object} StdioTransportOptions
+ * @property {Record<string, string>} [env]
+ * @property {"inherit" | "ignore" | "pipe" | string} [stderr]
+ * @property {(method: string, params?: unknown) => void} [onNotification]
+ */
+
+/**
+ * JSON-RPC 2.0 transport over stdio.
+ * Manages the child process lifecycle and message passing.
+ */
+export class StdioTransport {
+  /** @type {import("node:child_process").ChildProcess} */
+  #process;
+  /** @type {import("node:readline").Interface} */
+  #rl;
+  #nextId = 1;
+  /** @type {Map<number, { resolve: (value: any) => void, reject: (reason: any) => void, timer: NodeJS.Timeout }>} */
+  #pendingRequests = new Map();
+  #closed = false;
+  /** @type {Error | undefined} */
+  #earlyExitError;
+  /** @type {((line: string) => void)} */
+  #onLine;
+  /** @type {((code: number | null) => void)} */
+  #onClose;
+  /** @type {((err: Error) => void)} */
+  #onError;
+  /** @type {number | undefined} */
+  #stderrFd;
+  /** @type {((method: string, params?: unknown) => void) | undefined} */
+  // Currently unused by callers, but provided for MCP protocol compliance (e.g. notifications/progress).
+  #onNotification;
+
+  /**
+   * @param {string} command
+   * @param {string[]} [args]
+   * @param {StdioTransportOptions} [options]
+   */
+  constructor(command, args, options = {}) {
+    const defaultEnv = {
+      PWD: process.env.PWD || "",
+      PATH: process.env.PATH || "",
+      HOME: process.env.HOME || "",
+    };
+
+    /** @type {"inherit" | "ignore" | "pipe" | number} */
+    let stderrValue = "ignore";
+    if (
+      options.stderr === "inherit" ||
+      options.stderr === "ignore" ||
+      options.stderr === "pipe"
+    ) {
+      stderrValue = options.stderr;
+    } else if (typeof options.stderr === "string") {
+      this.#stderrFd = openSync(options.stderr, "a");
+      stderrValue = this.#stderrFd;
+    }
+
+    const childProcess = spawn(command, args || [], {
+      env: { ...defaultEnv, ...options.env },
+      stdio: /** @type {import("node:child_process").StdioOptions} */ ([
+        "pipe",
+        "pipe",
+        stderrValue,
+      ]),
+    });
+
+    this.#process = childProcess;
+    this.#onNotification = options.onNotification;
+
+    if (!childProcess.stdout) {
+      throw new Error("MCP server stdout is not available");
+    }
+    this.#rl = createInterface({ input: childProcess.stdout });
+
+    this.#onLine = (line) => this.#handleLine(line);
+    this.#rl.on("line", this.#onLine);
+
+    this.#onClose = (code) => this.#handleProcessClose(code);
+    childProcess.on("close", this.#onClose);
+
+    this.#onError = (err) => this.#handleProcessError(err);
+    childProcess.on("error", this.#onError);
+  }
+
+  /**
+   * @returns {import("node:child_process").ChildProcess}
+   */
+  get process() {
+    return this.#process;
+  }
+
+  /**
+   * @param {string} line
+   */
+  #handleLine(line) {
+    if (!line.trim()) return;
+    try {
+      const msg = JSON.parse(line);
+      if (!("id" in msg)) {
+        this.#onNotification?.(msg.method, msg.params);
+        return;
+      }
+      if (this.#pendingRequests.has(msg.id)) {
+        const pending = this.#pendingRequests.get(msg.id);
+        if (!pending) return;
+        this.#pendingRequests.delete(msg.id);
+        clearTimeout(pending.timer);
+        if (msg.error) {
+          pending.reject(
+            new Error(msg.error.message || JSON.stringify(msg.error)),
+          );
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+    } catch {
+      // Ignore non-JSON lines
+    }
+  }
+
+  /**
+   * @param {number | null} code
+   */
+  #handleProcessClose(code) {
+    const err = new Error(`MCP server exited with code ${code}`);
+    this.#earlyExitError = err;
+    this.#rejectAllPending(err);
+  }
+
+  /**
+   * @param {Error} err
+   */
+  #handleProcessError(err) {
+    this.#earlyExitError = err;
+    this.#rejectAllPending(err);
+  }
+
+  /**
+   * @param {Error} error
+   */
+  #rejectAllPending(error) {
+    for (const [, { reject, timer }] of this.#pendingRequests) {
+      clearTimeout(timer);
+      reject(error);
+    }
+    this.#pendingRequests.clear();
+  }
+
+  /**
+   * @param {string} method
+   * @param {Record<string, unknown>} [params]
+   * @param {number} [timeoutMs]
+   * @returns {Promise<any>}
+   */
+  request(method, params, timeoutMs = 30000) {
+    if (this.#closed) {
+      return Promise.reject(new Error("MCP client is closed"));
+    }
+    if (this.#earlyExitError) {
+      return Promise.reject(this.#earlyExitError);
+    }
+    const id = this.#nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.#pendingRequests.delete(id);
+        reject(new Error(`Request ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this.#pendingRequests.set(id, { resolve, reject, timer });
+      const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+      this.#process.stdin?.write(`${msg}\n`, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.#pendingRequests.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * @param {string} method
+   * @param {Record<string, unknown>} [params]
+   */
+  notify(method, params) {
+    if (this.#closed || this.#earlyExitError) return;
+    const msg = JSON.stringify(
+      params ? { jsonrpc: "2.0", method, params } : { jsonrpc: "2.0", method },
+    );
+    this.#process.stdin?.write(`${msg}\n`, () => {
+      // Ignore write errors in notifications
+    });
+  }
+
+  /**
+   * @param {NodeJS.Signals} [signal]
+   * @param {number} [timeoutMs]
+   * @returns {Promise<void>}
+   */
+  async close(signal = "SIGTERM", timeoutMs = 5000) {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#rejectAllPending(new Error("MCP client is closed"));
+    this.#rl.off("line", this.#onLine);
+    this.#rl.close();
+    this.#process.stdin?.end();
+    this.#process.off("close", this.#onClose);
+    this.#process.off("error", this.#onError);
+
+    const closePromise = new Promise((resolve) => {
+      if (
+        this.#process.exitCode !== null ||
+        this.#process.signalCode !== null
+      ) {
+        resolve(undefined);
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.#process.kill("SIGKILL");
+        resolve(undefined);
+      }, timeoutMs);
+      this.#process.once("close", () => {
+        clearTimeout(timer);
+        resolve(undefined);
+      });
+    });
+
+    this.#process.kill(signal);
+    await closePromise;
+
+    if (this.#stderrFd !== undefined) {
+      try {
+        closeSync(this.#stderrFd);
+      } catch {
+        // ignore
+      }
+    }
+  }
+}

package/src/mcpClient.test.mockServer.mjs

@@ -0,0 +1,83 @@
+/**
+ * Mock MCP server for testing.
+ * Speaks JSON-RPC 2.0 over stdio.
+ * Handles: initialize, notifications/initialized, tools/list, tools/call.
+ */
+
+import { createInterface } from "node:readline";
+
+const rl = createInterface({ input: process.stdin });
+
+rl.on("line", (line) => {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (msg.method === "initialize") {
+    respond(msg.id, {
+      protocolVersion: "2025-03-26",
+      capabilities: {},
+      serverInfo: { name: "mock", version: "0.0.0" },
+    });
+    return;
+  }
+
+  if (msg.method === "notifications/initialized") {
+    return;
+  }
+
+  if (msg.method === "tools/list") {
+    respond(msg.id, {
+      tools: [
+        {
+          name: "echo",
+          description: "Echo tool",
+          inputSchema: {
+            type: "object",
+            properties: { text: { type: "string" } },
+          },
+        },
+        {
+          name: "add",
+          description: "Add numbers",
+          inputSchema: {
+            type: "object",
+            properties: {
+              a: { type: "number" },
+              b: { type: "number" },
+            },
+          },
+        },
+      ],
+    });
+    return;
+  }
+
+  if (msg.method === "tools/call") {
+    const { name, arguments: args } = msg.params;
+    if (name === "echo") {
+      respond(msg.id, { content: [{ type: "text", text: args.text }] });
+    } else if (name === "add") {
+      respond(msg.id, {
+        content: [{ type: "text", text: String(args.a + args.b) }],
+      });
+    } else if (name === "error_tool") {
+      respondError(msg.id, -1, "tool failed");
+    }
+  }
+});
+
+/** @param {number} id @param {unknown} result */
+function respond(id, result) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+}
+
+/** @param {number} id @param {number} code @param {string} message */
+function respondError(id, code, message) {
+  process.stdout.write(
+    `${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`,
+  );
+}

package/src/{mcp.mjs → mcpIntegration.mjs}

@@ -1,15 +1,17 @@
 /**
- * @import { Client } from "@modelcontextprotocol/client";
  * @import { StructuredToolResultContent, Tool, ToolImplementation } from "./tool";
  * @import { MCPServerConfig } from "./config";
  */
 
-import { mkdir, open } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_PROJECT_METADATA_DIR } from "./env.mjs";
+import { createMCPClient } from "./mcpClient.mjs";
 import { writeTmpFile } from "./tmpfile.mjs";
 import { noThrow } from "./utils/noThrow.mjs";
 
+/** @typedef {import("./mcpClient.mjs").MCPClient} MCPClient */
+
 const OUTPUT_MAX_LENGTH = 1024 * 8;
 
 /**
@@ -27,9 +29,14 @@ const OUTPUT_MAX_LENGTH = 1024 * 8;
 export async function setupMCPServer(serverName, serverConfig) {
   const { options, ...params } = serverConfig;
 
-  const { client, stderrLogPath, cleanup } = await startMCPServer({
-    serverName,
-    params,
+  // Ensure log directory exists and open stderr log file
+  const logDir = path.join(AGENT_PROJECT_METADATA_DIR, "logs");
+  await mkdir(logDir, { recursive: true });
+  const logPath = path.join(logDir, `mcp--${serverName}.stderr`);
+
+  const client = await createMCPClient({
+    ...params,
+    stderr: logPath,
   });
 
   const tools = (await createMCPTools(serverName, client)).filter(
@@ -42,65 +49,17 @@ export async function setupMCPServer(serverName, serverConfig) {
 
   return {
     tools,
-    stderrLogPath,
+    stderrLogPath: logPath,
     cleanup: async () => {
-      cleanup();
       await client.close();
     },
   };
 }
 
-/**
- * @typedef {Object} MCPClientOptions
- * @property {string} serverName - The name of the MCP server.
- * @property {import("@modelcontextprotocol/client").StdioServerParameters} params - The transport to use for the client.
- */
-
-/**
- * @param {MCPClientOptions} options - The options for the client.
- * @returns {Promise<{client: Client; stderrLogPath: string; cleanup: () => void}>} - The MCP client, stderr log path, and cleanup function.
- */
-async function startMCPServer(options) {
-  const mcpClient = await import("@modelcontextprotocol/client");
-
-  const client = new mcpClient.Client({
-    name: "undefined",
-    version: "undefined",
-  });
-
-  const { env, ...restParams } = options.params;
-  const defaultEnv = {
-    PWD: process.env.PWD || "",
-    PATH: process.env.PATH || "",
-    HOME: process.env.HOME || "",
-  };
-
-  // Ensure log directory exists and open stderr log file
-  const logDir = path.join(AGENT_PROJECT_METADATA_DIR, "logs");
-  await mkdir(logDir, { recursive: true });
-  const logPath = path.join(logDir, `mcp--${options.serverName}.stderr`);
-  const stderrLogFile = await open(logPath, "a");
-
-  const transport = new mcpClient.StdioClientTransport({
-    ...restParams,
-    env: env ? { ...defaultEnv, ...env } : undefined,
-    stderr: stderrLogFile.fd,
-  });
-  await client.connect(transport);
-
-  return {
-    client,
-    stderrLogPath: logPath,
-    cleanup: () => {
-      stderrLogFile.close();
-    },
-  };
-}
-
 /**
  * @param {string} serverName
- * @param {Client} client - The MCP client.
- * @returns {Promise<Tool[]>} - The list of tools.
+ * @param {MCPClient} client
+ * @returns {Promise<Tool[]>}
  */
 async function createMCPTools(serverName, client) {
   const { tools: mcpTools } = await client.listTools();

package/src/modelDefinition.d.ts

@@ -1,8 +1,8 @@
 import { AnthropicModelConfig } from "./providers/anthropic";
+import { BedrockConverseModelConfig } from "./providers/bedrock";
 import { GeminiModelConfig } from "./providers/gemini";
 import { OpenAIModelConfig } from "./providers/openai";
 import { OpenAICompatibleModelConfig } from "./providers/openaiCompatible";
-import { BedrockConverseModelConfig } from "./providers/bedrock";
 
 export type ModelDefinition = {
   name: string;

package/src/prompt.mjs

@@ -2,9 +2,10 @@
  * @typedef {object} PromptConfig
  * @property {string} username
  * @property {string} modelName
+ * @property {string} workingDir - The current working directory.
+ * @property {string} today - Today's date in YYYY-MM-DD format.
  * @property {string} sessionId
  * @property {string} tmuxSessionId
- * @property {string} workingDir - The current working directory.
  * @property {string} projectMetadataDir - The directory where memory files are stored.
  * @property {Map<string, import('./context/loadAgentRoles.mjs').AgentRole>} agentRoles - Available agent roles.
  * @property {{filePath: string, description: string}[]} skills
@@ -18,6 +19,7 @@ export function createPrompt({
   username,
   modelName,
   sessionId,
+  today,
   tmuxSessionId,
   workingDir,
   projectMetadataDir,
@@ -103,7 +105,7 @@ Discover and apply project-specific rules and reusable skills.
 ## AGENTS.md (falling back to CLAUDE.md if not found): Project-specific rules, conventions, and commands.
 
 Find: fd ["^(AGENTS|CLAUDE)\\.md$", "./", "--hidden", "--max-depth", "5"]
-Read from root to target: ./AGENTS.md → dir/AGENTS.md → dir/subdir/AGENTS.md
+Read from the project root to the directory you're working in: ./AGENTS.md → dir/AGENTS.md → dir/subdir/AGENTS.md
 Apply rules when working in that directory
 
 ## SKILL.md: Reusable workflows with specialized knowledge
@@ -117,6 +119,7 @@ ${skillDescriptions}
 - User name: ${username}
 - Your model name: ${modelName}
 - Current working directory: ${workingDir}
+- Today's date: ${today}
 - Session id: ${sessionId}
 - Tmux session id: ${tmuxSessionId}
 - Memory file path: ${projectMetadataDir}/memory/${sessionId}--<kebab-case-title>.md

package/src/providers/anthropic.mjs

@@ -6,6 +6,7 @@
 
 import { styleText } from "node:util";
 import { noThrow } from "../utils/noThrow.mjs";
+import { loadAwsCredentials, signAwsRequest } from "./platform/awsSigV4.mjs";
 import { readBedrockStreamEvents } from "./platform/bedrock.mjs";
 import { getGoogleCloudAccessToken } from "./platform/googleCloud.mjs";
 
@@ -108,39 +109,28 @@ export async function callAnthropicModel(
 
     // bedrock + sso profile
     const runFetchForBedrock = async () => {
-      const { Sha256 } = await import("@aws-crypto/sha256-js");
-      const { fromIni } = await import("@aws-sdk/credential-providers");
-      const { HttpRequest } = await import("@smithy/protocol-http");
-      const { SignatureV4 } = await import("@smithy/signature-v4");
-
       const region =
         url.match(/bedrock-runtime\.([\w-]+)\.amazonaws\.com/)?.[1] ?? "";
       const urlParsed = new URL(url);
       const { hostname, pathname } = urlParsed;
 
-      const signer = new SignatureV4({
-        credentials: fromIni({
-          profile:
-            platformConfig.name === "bedrock" ? platformConfig.awsProfile : "",
-        }),
-        region,
-        service: "bedrock",
-        sha256: Sha256,
-      });
+      const credentials = await loadAwsCredentials(
+        platformConfig.name === "bedrock" ? platformConfig.awsProfile : "",
+      );
 
-      const req = new HttpRequest({
-        protocol: "https:",
-        method: "POST",
-        hostname,
-        path: pathname,
-        headers: {
-          host: hostname,
-          "Content-Type": "application/json",
+      const signed = signAwsRequest(
+        {
+          method: "POST",
+          hostname,
+          path: pathname,
+          headers: {
+            host: hostname,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(request),
         },
-        body: JSON.stringify(request),
-      });
-
-      const signed = await signer.sign(req);
+        { region, service: "bedrock", credentials },
+      );
 
       return fetch(url, {
         method: signed.method,

package/src/providers/bedrock.mjs

@@ -6,6 +6,7 @@
 
 import { styleText } from "node:util";
 import { noThrow } from "../utils/noThrow.mjs";
+import { loadAwsCredentials, signAwsRequest } from "./platform/awsSigV4.mjs";
 import { readBedrockStreamEvents } from "./platform/bedrock.mjs";
 
 /**
@@ -21,11 +22,6 @@ export async function callBedrockConverseModel(
   input,
   retryCount = 0,
 ) {
-  const { Sha256 } = await import("@aws-crypto/sha256-js");
-  const { fromIni } = await import("@aws-sdk/credential-providers");
-  const { HttpRequest } = await import("@smithy/protocol-http");
-  const { SignatureV4 } = await import("@smithy/signature-v4");
-
   return await noThrow(async () => {
     const messages = convertGenericMessageToBedrockFormat(input.messages);
     const cachedMessages = modelConfig.enablePromptCaching
@@ -75,29 +71,23 @@ export async function callBedrockConverseModel(
     const payload = JSON.stringify(request);
 
     // Sign request with AWS Signature V4
-    const signer = new SignatureV4({
-      credentials: fromIni({ profile: platformConfig.awsProfile }),
-      region,
-      service: "bedrock",
-      sha256: Sha256,
-    });
-
+    const credentials = await loadAwsCredentials(platformConfig.awsProfile);
     const urlParsed = new URL(url);
     const { hostname, pathname } = urlParsed;
 
-    const req = new HttpRequest({
-      protocol: "https:",
-      method: "POST",
-      hostname,
-      path: pathname,
-      headers: {
-        host: hostname,
-        "Content-Type": "application/json",
+    const signed = signAwsRequest(
+      {
+        method: "POST",
+        hostname,
+        path: pathname,
+        headers: {
+          host: hostname,
+          "Content-Type": "application/json",
+        },
+        body: payload,
       },
-      body: payload,
-    });
-
-    const signed = await signer.sign(req);
+      { region, service: "bedrock", credentials },
+    );
 
     const response = await fetch(url, {
       method: signed.method,

package/src/providers/openaiCompatible.mjs

@@ -7,6 +7,7 @@
 import { styleText } from "node:util";
 import { noThrow } from "../utils/noThrow.mjs";
 import { retryOnError } from "../utils/retryOnError.mjs";
+import { loadAwsCredentials, signAwsRequest } from "./platform/awsSigV4.mjs";
 import { readBedrockStreamEvents } from "./platform/bedrock.mjs";
 import { getGoogleCloudAccessToken } from "./platform/googleCloud.mjs";
 
@@ -111,39 +112,28 @@ export async function callOpenAICompatibleModel(
 
     // bedrock + sso profile
     const runFetchForBedrock = async () => {
-      const { Sha256 } = await import("@aws-crypto/sha256-js");
-      const { fromIni } = await import("@aws-sdk/credential-providers");
-      const { HttpRequest } = await import("@smithy/protocol-http");
-      const { SignatureV4 } = await import("@smithy/signature-v4");
-
       const region =
         url.match(/bedrock-runtime\.([\w-]+)\.amazonaws\.com/)?.[1] ?? "";
       const urlParsed = new URL(url);
       const { hostname, pathname } = urlParsed;
 
-      const signer = new SignatureV4({
-        credentials: fromIni({
-          profile:
-            platformConfig.name === "bedrock" ? platformConfig.awsProfile : "",
-        }),
-        region,
-        service: "bedrock",
-        sha256: Sha256,
-      });
+      const credentials = await loadAwsCredentials(
+        platformConfig.name === "bedrock" ? platformConfig.awsProfile : "",
+      );
 
-      const req = new HttpRequest({
-        protocol: "https:",
-        method: "POST",
-        hostname,
-        path: pathname,
-        headers: {
-          host: hostname,
-          "Content-Type": "application/json",
+      const signed = signAwsRequest(
+        {
+          method: "POST",
+          hostname,
+          path: pathname,
+          headers: {
+            host: hostname,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(request),
         },
-        body: JSON.stringify(request),
-      });
-
-      const signed = await signer.sign(req);
+        { region, service: "bedrock", credentials },
+      );
 
       return fetch(url, {
         method: signed.method,

package/src/providers/platform/awsSigV4.mjs

@@ -0,0 +1,161 @@
+import { execFile } from "node:child_process";
+import { createHash, createHmac } from "node:crypto";
+
+/**
+ * @typedef {{ accessKeyId: string, secretAccessKey: string, sessionToken?: string }} AwsCredentials
+ */
+
+/**
+ * Load AWS credentials for the given profile using the AWS CLI.
+ * @param {string} profile
+ * @returns {Promise<AwsCredentials>}
+ */
+export async function loadAwsCredentials(profile) {
+  /** @type {string} */
+  const stdout = await new Promise((resolve, reject) => {
+    execFile(
+      "aws",
+      ["configure", "export-credentials", "--profile", profile],
+      {
+        shell: false,
+        timeout: 30 * 1000,
+      },
+      (error, stdout, _stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(stdout.trim());
+      },
+    );
+  });
+  const parsed = JSON.parse(stdout);
+  for (const key of ["AccessKeyId", "SecretAccessKey"]) {
+    if (!parsed[key] || typeof parsed[key] !== "string") {
+      throw new Error(
+        `AWS credentials output missing ${key}. Raw output: ${stdout.slice(0, 200)}`,
+      );
+    }
+  }
+  return {
+    accessKeyId: parsed.AccessKeyId,
+    secretAccessKey: parsed.SecretAccessKey,
+    ...(parsed.SessionToken && { sessionToken: parsed.SessionToken }),
+  };
+}
+
+/**
+ * Sign an HTTP request with AWS Signature V4.
+ *
+ * Known limitation: if duplicate header names with different casing exist
+ * (e.g. `Content-Type` and `content-type`), only the first match is used.
+ * Per AWS SigV4 spec, values should be combined with commas. Callers should
+ * ensure header names are unique (case-insensitive) before signing.
+ *
+ * @param {{
+ *   method: string,
+ *   hostname: string,
+ *   path: string,
+ *   headers: Record<string, string>,
+ *   body: string,
+ * }} request
+ * @param {{
+ *   region: string,
+ *   service: string,
+ *   credentials: AwsCredentials,
+ * }} options
+ * @returns {{ method: string, headers: Record<string, string>, body: string }}
+ */
+export function signAwsRequest(request, options) {
+  const { method, hostname, path, headers, body } = request;
+  const { region, service, credentials } = options;
+
+  const now = new Date();
+  const amzDate = now
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}/, "");
+  const dateStamp = amzDate.slice(0, 8);
+
+  /** @type {Record<string, string>} */
+  const signedHeaders = { ...headers, host: hostname, "x-amz-date": amzDate };
+  if (credentials.sessionToken) {
+    signedHeaders["x-amz-security-token"] = credentials.sessionToken;
+  }
+
+  // Canonical headers: sorted, lowercased, trimmed
+  const sortedKeys = Object.keys(signedHeaders)
+    .map((k) => k.toLowerCase())
+    .sort();
+  const canonicalHeaders = sortedKeys
+    .map((k) => {
+      const original = Object.keys(signedHeaders).find(
+        (h) => h.toLowerCase() === k,
+      );
+      return `${k}:${signedHeaders[/** @type {string} */ (original)].trim()}`;
+    })
+    .join("\n");
+  const signedHeadersList = sortedKeys.join(";");
+
+  const payloadHash = sha256Hex(body || "");
+
+  // AWS SigV4 Canonical URI requires each path segment to be URI-encoded.
+  // URL.pathname returns a decoded string, so we need to re-encode it.
+  const canonicalUri = path
+    .split("/")
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+
+  const canonicalRequest = [
+    method,
+    canonicalUri,
+    "", // query string (empty for POST)
+    `${canonicalHeaders}\n`,
+    signedHeadersList,
+    payloadHash,
+  ].join("\n");
+
+  // String to sign
+  const scope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    scope,
+    sha256Hex(canonicalRequest),
+  ].join("\n");
+
+  // Signing key
+  const kDate = hmacSha256(`AWS4${credentials.secretAccessKey}`, dateStamp);
+  const kRegion = hmacSha256(kDate, region);
+  const kService = hmacSha256(kRegion, service);
+  const kSigning = hmacSha256(kService, "aws4_request");
+
+  const signature = createHmac("sha256", kSigning)
+    .update(stringToSign, "utf-8")
+    .digest("hex");
+
+  const authorization = `AWS4-HMAC-SHA256 Credential=${credentials.accessKeyId}/${scope}, SignedHeaders=${signedHeadersList}, Signature=${signature}`;
+
+  return {
+    method,
+    headers: { ...signedHeaders, Authorization: authorization },
+    body,
+  };
+}
+
+/**
+ * @param {string} data
+ * @returns {string}
+ */
+function sha256Hex(data) {
+  return createHash("sha256").update(data, "utf-8").digest("hex");
+}
+
+/**
+ * @param {string | Buffer} key
+ * @param {string} data
+ * @returns {Buffer}
+ */
+function hmacSha256(key, data) {
+  return createHmac("sha256", key).update(data, "utf-8").digest();
+}

package/src/tools/patchFile.mjs

@@ -57,6 +57,32 @@ other new content
       await noThrow(async () => {
         const { filePath, diff } = input;
 
+        // Validate marker counts: each block needs exactly one of each marker.
+        // Since nonce is random, duplicate markers mean the user accidentally
+        // included a marker line in their search/replace content (copy-paste error).
+        const searchMarker = `<<< ${nonce} <<< SEARCH`;
+        const sepMarker = `=== ${nonce} ===`;
+        const replaceMarker = `>>> ${nonce} >>> REPLACE`;
+        /** @type {(s: string, sub: string) => number} */
+        const count = (s, sub) => s.split(sub).length - 1;
+        const nSearch = count(diff, searchMarker);
+        const nSep = count(diff, sepMarker);
+        const nReplace = count(diff, replaceMarker);
+
+        if (nSearch !== nReplace) {
+          throw new Error(
+            `Mismatched block markers: found ${nSearch} "${searchMarker}" but ${nReplace} "${replaceMarker}". ` +
+              "Did you accidentally include a marker in your search/replace content?",
+          );
+        }
+        if (nSep !== nSearch) {
+          throw new Error(
+            `Each diff block needs exactly one "${sepMarker}" separator, ` +
+              `but found ${nSep} separators for ${nSearch} block(s). ` +
+              "Did you accidentally include the separator marker in your search/replace content?",
+          );
+        }
+
         const content = await fs.readFile(filePath, "utf8");
         const matches = Array.from(
           diff.matchAll(