@iinm/plain-agent 1.8.3 → 1.8.4

package/src/env.mjs

@@ -1,44 +0,0 @@
-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

@@ -1,279 +0,0 @@
-/**
- * @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 { createDelegateToSubagentTool } from "./tools/delegateToSubagent.mjs";
-import { createExecCommandTool } from "./tools/execCommand.mjs";
-import { createPatchFileTool } from "./tools/patchFile.mjs";
-import { createReportAsSubagentTool } from "./tools/reportAsSubagent.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 agentRoles = await loadAgentRoles(pluginPaths);
-  const prompts = await loadPrompts(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(),
-    createDelegateToSubagentTool(),
-    createReportAsSubagentTool(),
-  ];
-
-  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

@@ -1,351 +0,0 @@
-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
-      }
-    }
-  }
-}