@iinm/plain-agent 1.8.4 → 1.8.6

package/bin/plain

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import("../dist/main.mjs");
+import("../src/main.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",
@@ -17,27 +17,26 @@
     "bin",
     "sandbox/bin",
     "config",
-    "dist"
+    "src/**/*.mjs",
+    "src/**/*.d.ts",
+    "!src/**/*.test.mjs",
+    "!src/**/*.test.*.mjs",
+    "!src/**/*.playground.mjs",
+    "!src/**/test/"
   ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "build": "esbuild src/main.mjs --bundle --platform=node --target=node22 --outfile=dist/main.mjs --minify --sourcemap --format=esm --banner:js='import { createRequire } from \"node:module\";const require=createRequire(import.meta.url);'",
-    "prepublishOnly": "npm run build",
     "check": "npm run lint && tsc && npm run test",
     "test": "node --test",
     "lint": "npx @biomejs/biome check",
     "fix": "npx @biomejs/biome check --fix"
   },
-  "dependencies": {
-    "diff": "^8.0.4",
-    "yaml": "^2.8.3"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
     "@types/node": "^22.19.17",
-    "esbuild": "^0.28.0",
     "typescript": "^6.0.2"
   }
 }

package/sandbox/bin/plain-sandbox

@@ -731,6 +731,14 @@ setup_container_firewall() {
   # allow established connections
   iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
   iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+
+  # allow localhost on IPv6
+  ip6tables -A INPUT -i lo -j ACCEPT
+  ip6tables -A OUTPUT -o lo -j ACCEPT
+
+  # allow established connections on IPv6
+  ip6tables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+  ip6tables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
   
   # allow given addresses
   for address in "${addresses[@]}"; do
@@ -750,6 +758,11 @@ setup_container_firewall() {
     fi
   done
   iptables -A OUTPUT -p tcp -m set --match-set allow_list dst,dst -j ACCEPT
+
+  # Reject unauthorized TCP connections immediately with RST
+  # instead of silently dropping and causing timeout
+  iptables -A OUTPUT -p tcp -j REJECT --reject-with tcp-reset
+  ip6tables -A OUTPUT -p tcp -j REJECT --reject-with tcp-reset
 }
 
 setup_container_user() {

package/src/agent.d.ts

@@ -0,0 +1,52 @@
+import type { EventEmitter } from "node:events";
+import type { AgentRole } from "./context/loadAgentRoles.mjs";
+import type { CostConfig, CostSummary } from "./costTracker.mjs";
+import type {
+  CallModel,
+  Message,
+  MessageContentImage,
+  MessageContentText,
+  PartialMessageContent,
+  ProviderTokenUsage,
+} from "./model";
+import type { Tool, ToolUseApprover } from "./tool";
+
+export type Agent = {
+  userEventEmitter: UserEventEmitter;
+  agentEventEmitter: AgentEventEmitter;
+  agentCommands: AgentCommands;
+};
+
+export type AgentCommands = {
+  dumpMessages: () => Promise<void>;
+  loadMessages: () => Promise<void>;
+  getCostSummary: () => CostSummary;
+  pauseAutoApprove: () => void;
+};
+
+type UserEventMap = {
+  userInput: [(MessageContentText | MessageContentImage)[]];
+};
+
+export type UserEventEmitter = EventEmitter<UserEventMap>;
+
+type AgentEventMap = {
+  message: [Message];
+  partialMessageContent: [PartialMessageContent];
+  error: [Error];
+  toolUseRequest: [];
+  turnEnd: [];
+  providerTokenUsage: [ProviderTokenUsage];
+  subagentSwitched: [{ name: string } | null];
+};
+
+export type AgentEventEmitter = EventEmitter<AgentEventMap>;
+
+export type AgentConfig = {
+  callModel: CallModel;
+  prompt: string;
+  tools: Tool[];
+  toolUseApprover: ToolUseApprover;
+  agentRoles: Map<string, AgentRole>;
+  modelCostConfig?: CostConfig;
+};

package/src/agent.mjs

@@ -0,0 +1,204 @@
+/**
+ * @import { Agent, AgentConfig, AgentEventEmitter, UserEventEmitter } from "./agent"
+ * @import { Tool, ToolDefinition } from "./tool"
+ * @import { CompactContextInput } from "./tools/compactContext"
+ * @import { SwitchToSubagentInput } from "./tools/switchToSubagent"
+ * @import { SwitchToMainAgentInput } from "./tools/switchToMainAgent"
+ */
+
+import { EventEmitter } from "node:events";
+import fs from "node:fs/promises";
+import { createAgentLoop } from "./agentLoop.mjs";
+import { createStateManager } from "./agentState.mjs";
+import { createCostTracker } from "./costTracker.mjs";
+import { MESSAGES_DUMP_FILE_PATH } from "./env.mjs";
+import { createSubagentManager } from "./subagent.mjs";
+import { createToolExecutor } from "./toolExecutor.mjs";
+import {
+  compactContextToolName,
+  readMemoryForCompaction,
+} from "./tools/compactContext.mjs";
+import { switchToMainAgentToolName } from "./tools/switchToMainAgent.mjs";
+import { switchToSubagentToolName } from "./tools/switchToSubagent.mjs";
+
+/**
+ * @param {AgentConfig} config
+ * @returns {Agent}
+ */
+export function createAgent({
+  callModel,
+  prompt,
+  tools,
+  toolUseApprover,
+  agentRoles,
+  modelCostConfig,
+}) {
+  /** @type {UserEventEmitter} */
+  const userEventEmitter = new EventEmitter();
+  /** @type {AgentEventEmitter} */
+  const agentEventEmitter = new EventEmitter();
+
+  const costTracker = createCostTracker(modelCostConfig);
+
+  agentEventEmitter.on("providerTokenUsage", (usage) => {
+    costTracker.recordUsage(usage);
+  });
+
+  const stateManager = createStateManager(
+    [
+      {
+        role: "system",
+        content: [{ type: "text", text: prompt }],
+      },
+    ],
+    {
+      onMessagesAppended: (newMessages) => {
+        const lastMessage = newMessages.at(-1);
+        if (!lastMessage) {
+          return;
+        }
+        agentEventEmitter.emit("message", lastMessage);
+      },
+    },
+  );
+
+  const subagentManager = createSubagentManager(agentRoles, {
+    onSubagentSwitched: (subagent) => {
+      agentEventEmitter.emit("subagentSwitched", subagent);
+    },
+  });
+
+  /**
+   * @param {SwitchToSubagentInput} input
+   */
+  const switchToSubagentImpl = async (input) => {
+    const result = subagentManager.switchToSubagent(
+      input.name,
+      input.goal,
+      stateManager.getMessages().length - 1,
+    );
+    if (!result.success) {
+      return new Error(result.error);
+    }
+    return result.value;
+  };
+
+  /**
+   * @param {SwitchToMainAgentInput} input
+   */
+  const switchToMainAgentImpl = async (input) => {
+    const result = await subagentManager.switchToMainAgent(input.memoryPath);
+    if (!result.success) {
+      return new Error(result.error);
+    }
+    return result.memoryContent;
+  };
+
+  /**
+   * @param {Record<string, unknown>} rawInput
+   */
+  const compactContextImpl = async (rawInput) => {
+    if (subagentManager.isSubagentActive()) {
+      return new Error(
+        "compact_context cannot be used while running as a subagent. " +
+          "Call switch_to_main_agent to return to the main agent first.",
+      );
+    }
+    const input = /** @type {CompactContextInput} */ (rawInput);
+    return await readMemoryForCompaction(input);
+  };
+
+  /** @type {Map<string, Tool>} */
+  const toolByName = new Map();
+  for (const tool of tools) {
+    if (tool.def.name === switchToSubagentToolName && tool.injectImpl) {
+      tool.injectImpl(switchToSubagentImpl);
+    }
+    if (tool.def.name === switchToMainAgentToolName && tool.injectImpl) {
+      tool.injectImpl(switchToMainAgentImpl);
+    }
+    if (tool.def.name === compactContextToolName && tool.injectImpl) {
+      tool.injectImpl(compactContextImpl);
+    }
+    toolByName.set(tool.def.name, tool);
+  }
+
+  /** @type {ToolDefinition[]} */
+  const toolDefs = tools.map(({ def }) => def);
+
+  const toolExecutor = createToolExecutor(toolByName, {
+    exclusiveToolNames: [switchToSubagentToolName, switchToMainAgentToolName],
+  });
+
+  async function dumpMessages() {
+    const filePath = MESSAGES_DUMP_FILE_PATH;
+    try {
+      await fs.writeFile(
+        filePath,
+        JSON.stringify(stateManager.getMessages(), null, 2),
+      );
+      console.log(`Messages dumped to ${filePath}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error dumping messages: ${message}`);
+    }
+  }
+
+  async function loadMessages() {
+    const filePath = MESSAGES_DUMP_FILE_PATH;
+    try {
+      const data = await fs.readFile(filePath, "utf-8");
+      const loadedMessages = JSON.parse(data);
+      if (Array.isArray(loadedMessages)) {
+        // Keep the system message (index 0) and replace the rest
+        stateManager.setMessages([
+          stateManager.getMessageAt(0),
+          ...loadedMessages.slice(1),
+        ]);
+        console.log(`Messages loaded from ${filePath}`);
+      } else {
+        console.error("Error loading messages: Invalid format in file.");
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error loading messages: ${error.message}`);
+      }
+    }
+  }
+
+  // Pause signal: set by Ctrl-C during agent execution, checked after each tool batch completes
+  let paused = false;
+  /** @type {import("./agentLoop.mjs").PauseSignal} */
+  const pauseSignal = {
+    isPaused: () => paused,
+    reset: () => {
+      paused = false;
+    },
+  };
+
+  const agentLoop = createAgentLoop({
+    callModel,
+    stateManager,
+    toolDefs,
+    toolExecutor,
+    agentEventEmitter,
+    toolUseApprover,
+    subagentManager,
+    pauseSignal,
+  });
+
+  userEventEmitter.on("userInput", agentLoop.handleUserInput);
+
+  return {
+    userEventEmitter,
+    agentEventEmitter,
+    agentCommands: {
+      dumpMessages,
+      loadMessages,
+      getCostSummary: () => costTracker.calculateCost(),
+      pauseAutoApprove: () => {
+        paused = true;
+      },
+    },
+  };
+}