@iinm/plain-agent 1.8.4 → 1.8.5

package/src/env.mjs

@@ -0,0 +1,44 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const filename = fileURLToPath(import.meta.url);
+export const AGENT_ROOT = path.dirname(path.dirname(filename));
+
+export const AGENT_USER_CONFIG_DIR = path.join(
+  os.homedir(),
+  ".config",
+  "plain-agent",
+);
+export const AGENT_CACHE_DIR = path.join(os.homedir(), ".cache", "plain-agent");
+
+export const AGENT_DATA_DIR = path.join(
+  os.homedir(),
+  ".local",
+  "share",
+  "plain-agent",
+);
+
+export const USAGE_LOG_PATH = path.join(AGENT_DATA_DIR, "usage.jsonl");
+
+export const TRUSTED_CONFIG_HASHES_DIR = path.join(
+  AGENT_CACHE_DIR,
+  "trusted-config-hashes",
+);
+
+export const AGENT_PROJECT_METADATA_DIR = ".plain-agent";
+
+export const AGENT_MEMORY_DIR = path.join(AGENT_PROJECT_METADATA_DIR, "memory");
+export const AGENT_TMP_DIR = path.join(AGENT_PROJECT_METADATA_DIR, "tmp");
+
+export const CLAUDE_CODE_PLUGIN_DIR = path.join(
+  AGENT_PROJECT_METADATA_DIR,
+  "claude-code-plugins",
+);
+
+export const MESSAGES_DUMP_FILE_PATH = path.join(
+  AGENT_PROJECT_METADATA_DIR,
+  "messages.json",
+);
+
+export const USER_NAME = process.env.USER || "unknown";

package/src/main.mjs

@@ -0,0 +1,281 @@
+/**
+ * @import { Tool } from "./tool";
+ */
+
+import { styleText } from "node:util";
+import { createAgent } from "./agent.mjs";
+import {
+  installClaudeCodePlugins,
+  resolvePluginPaths,
+} from "./claudeCodePlugin.mjs";
+import { parseCliArgs, printHelp } from "./cliArgs.mjs";
+import { startBatchSession } from "./cliBatch.mjs";
+import { runCostCommand } from "./cliCost.mjs";
+import { startInteractiveSession } from "./cliInteractive.mjs";
+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 "./mcpIntegration.mjs";
+import { createModelCaller } from "./modelCaller.mjs";
+import { createPrompt } from "./prompt.mjs";
+import { createAskURLTool } from "./tools/askURL.mjs";
+import { createAskWebTool } from "./tools/askWeb.mjs";
+import { createCompactContextTool } from "./tools/compactContext.mjs";
+import { createExecCommandTool } from "./tools/execCommand.mjs";
+import { createPatchFileTool } from "./tools/patchFile.mjs";
+import { createSwitchToMainAgentTool } from "./tools/switchToMainAgent.mjs";
+import { createSwitchToSubagentTool } from "./tools/switchToSubagent.mjs";
+import { createTmuxCommandTool } from "./tools/tmuxCommand.mjs";
+import { writeFileTool } from "./tools/writeFile.mjs";
+import { createToolUseApprover } from "./toolUseApprover.mjs";
+
+const cliArgs = parseCliArgs(process.argv);
+if (cliArgs.subcommand.type === "help") {
+  printHelp();
+}
+
+if (cliArgs.subcommand.type === "list-models") {
+  const { appConfig } = await loadAppConfig({ skipTrustCheck: true });
+  if (!appConfig.models || appConfig.models.length === 0) {
+    console.error("No models found in configuration.");
+    process.exit(1);
+  }
+  for (const model of appConfig.models) {
+    const platform = model.platform;
+    console.log(
+      `${model.name}+${model.variant} (platform: ${platform.name}+${platform.variant})`,
+    );
+  }
+  process.exit(0);
+}
+
+if (cliArgs.subcommand.type === "install-claude-code-plugins") {
+  await installClaudeCodePlugins();
+  process.exit(0);
+}
+
+if (cliArgs.subcommand.type === "cost") {
+  try {
+    const exitCode = await runCostCommand({
+      from: cliArgs.subcommand.from,
+      to: cliArgs.subcommand.to,
+    });
+    process.exit(exitCode);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exit(1);
+  }
+}
+
+(async () => {
+  const startTime = new Date();
+  const sessionId = [
+    `${startTime.getFullYear()}-${`0${startTime.getMonth() + 1}`.slice(-2)}-${`0${startTime.getDate()}`.slice(-2)}`,
+    `0${startTime.getHours()}`.slice(-2) +
+      `0${startTime.getMinutes()}`.slice(-2),
+  ].join("-");
+  const tmuxSessionId = `agent-${sessionId}`;
+
+  const isBatchMode = cliArgs.subcommand.type === "batch";
+  const configFiles =
+    cliArgs.subcommand.type === "batch" ||
+    cliArgs.subcommand.type === "interactive"
+      ? cliArgs.subcommand.config
+      : [];
+
+  const { appConfig, loadedConfigPath } = await loadAppConfig({
+    skipUserConfig: isBatchMode,
+    skipTrustCheck: isBatchMode,
+    configFiles,
+  });
+
+  // In batch mode, skip human-readable output
+  if (!isBatchMode) {
+    if (loadedConfigPath.length > 0) {
+      console.log(styleText("green", "\n⚡ Loaded configuration files"));
+      console.log(loadedConfigPath.map((p) => `  ⤷ ${p}`).join("\n"));
+    }
+
+    if (appConfig.sandbox) {
+      const sandboxStr = [
+        appConfig.sandbox.command,
+        ...(appConfig.sandbox.args || []),
+      ].join(" ");
+      console.log(styleText("green", "\n📦 Sandbox: on"));
+      console.log(`  ⤷ ${sandboxStr}`);
+    } else {
+      console.log(styleText("yellow", "\n📦 Sandbox: off"));
+    }
+  }
+
+  /** @type {(() => Promise<void>)[]} */
+  const mcpCleanups = [];
+
+  /** @type {Tool[]} */
+  const mcpTools = [];
+  if (appConfig.mcpServers) {
+    const mcpServerEntries = Object.entries(appConfig.mcpServers);
+
+    if (!isBatchMode) {
+      console.log();
+      for (const [serverName] of mcpServerEntries) {
+        console.log(
+          styleText("blue", `🔌 Connecting to MCP server: ${serverName}...`),
+        );
+      }
+    }
+
+    const mcpResults = await Promise.all(
+      mcpServerEntries.map(async ([serverName, serverConfig]) => {
+        const result = await setupMCPServer(serverName, serverConfig);
+        return { serverName, ...result };
+      }),
+    );
+
+    for (const { serverName, tools, stderrLogPath, cleanup } of mcpResults) {
+      mcpTools.push(...tools);
+      mcpCleanups.push(cleanup);
+      if (!isBatchMode) {
+        console.log(
+          styleText(
+            "green",
+            `✅ Successfully connected to MCP server: ${serverName}`,
+          ),
+        );
+        console.log(`  ⤷ stderr log: ${stderrLogPath}`);
+      }
+    }
+  }
+
+  const modelFromConfig = appConfig.model || "";
+  const modelFromArgs =
+    cliArgs.subcommand.type === "batch" ||
+    cliArgs.subcommand.type === "interactive"
+      ? cliArgs.subcommand.model
+      : null;
+  const modelNameWithVariant = modelFromArgs || modelFromConfig;
+
+  const pluginPaths = resolvePluginPaths(appConfig.claudeCodePlugins ?? []);
+  const [prompts, agentRoles] = await Promise.all([
+    loadPrompts(pluginPaths),
+    loadAgentRoles(pluginPaths),
+  ]);
+
+  const prompt = createPrompt({
+    username: USER_NAME,
+    modelName: modelNameWithVariant,
+    workingDir: process.cwd(),
+    today: new Date().toISOString().split("T")[0],
+    sessionId,
+    tmuxSessionId,
+    projectMetadataDir: AGENT_PROJECT_METADATA_DIR,
+    agentRoles,
+    skills: Array.from(prompts.values()).filter((p) => p.isSkill),
+  });
+
+  const builtinTools = [
+    createExecCommandTool({ sandbox: appConfig.sandbox }),
+    writeFileTool,
+    createPatchFileTool(),
+    createTmuxCommandTool({ sandbox: appConfig.sandbox }),
+    createCompactContextTool(),
+    createSwitchToSubagentTool(),
+    createSwitchToMainAgentTool(),
+  ];
+
+  if (appConfig.tools?.askWeb) {
+    builtinTools.push(createAskWebTool(appConfig.tools.askWeb));
+  }
+
+  if (appConfig.tools?.askURL) {
+    builtinTools.push(createAskURLTool(appConfig.tools.askURL));
+  }
+
+  const toolUseApprover = createToolUseApprover({
+    maxApprovals: appConfig.autoApproval?.maxApprovals || 50,
+    defaultAction: appConfig.autoApproval?.defaultAction || "ask",
+    patterns: appConfig.autoApproval?.patterns || [],
+    maskApprovalInput: (toolName, input) => {
+      for (const tool of builtinTools) {
+        if (tool.def.name === toolName && tool.maskApprovalInput) {
+          return tool.maskApprovalInput(input);
+        }
+      }
+      return input;
+    },
+  });
+
+  const [modelName, modelVariant] = modelNameWithVariant.split("+");
+  const modelDef = (appConfig.models ?? []).find(
+    (entry) => entry.name === modelName && entry.variant === modelVariant,
+  );
+  if (!modelDef) {
+    throw new Error(
+      `Model "${modelNameWithVariant}" not found in configuration.`,
+    );
+  }
+
+  const platform = (appConfig.platforms ?? []).find(
+    (entry) =>
+      entry.name === modelDef.platform.name &&
+      entry.variant === modelDef.platform.variant,
+  );
+  if (!platform) {
+    throw new Error(
+      `Platform ${modelDef.platform.name} variant=${modelDef.platform.variant} not found in configuration.`,
+    );
+  }
+
+  const { userEventEmitter, agentEventEmitter, agentCommands } = createAgent({
+    callModel: createModelCaller({
+      ...modelDef,
+      platform: {
+        ...modelDef.platform,
+        ...platform,
+      },
+    }),
+    prompt,
+    tools: [...builtinTools, ...mcpTools],
+    toolUseApprover,
+    agentRoles,
+    modelCostConfig: modelDef.cost,
+  });
+
+  const sessionOptions = {
+    userEventEmitter,
+    agentEventEmitter,
+    agentCommands,
+    sessionId,
+    modelName: modelNameWithVariant,
+    sandbox: Boolean(appConfig.sandbox),
+    startTime,
+    onStop: async () => {
+      for (const cleanup of mcpCleanups) {
+        await cleanup();
+      }
+    },
+  };
+
+  if (cliArgs.subcommand.type === "batch") {
+    const task = cliArgs.subcommand.task;
+    if (!task) {
+      throw new Error("Batch task is required in batch mode");
+    }
+    await startBatchSession({
+      ...sessionOptions,
+      task,
+    });
+  } else {
+    startInteractiveSession({
+      ...sessionOptions,
+      notifyCmd: appConfig.notifyCmd,
+      claudeCodePlugins: resolvePluginPaths(appConfig.claudeCodePlugins ?? []),
+      voiceInput: appConfig.voiceInput,
+    });
+  }
+})().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

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
+      }
+    }
+  }
+}