@moikapy/lich 0.6.0 → 0.7.0

package/dist/{chunk-7HLVKVIG.js → chunk-QVJCIZIF.js}

@@ -1912,12 +1912,178 @@ function read_platform_token(config, platform) {
   return value;
 }
 
+// src/mcp/mcp_pin.ts
+import path11 from "path";
+
+// src/mcp/mcp_catalog.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cached;
+function catalog_dir() {
+  let dir = path9.dirname(fileURLToPath2(import.meta.url));
+  for (let hop = 0; hop < 6; hop += 1) {
+    const candidate = path9.join(dir, "optional-mcps");
+    if (existsSync2(path9.join(candidate, "redot", "manifest.json")) === true) {
+      return candidate;
+    }
+    dir = path9.dirname(dir);
+  }
+  throw new Error("mcp catalog not found");
+}
+function read_manifest(file) {
+  const parsed = safe_json_parse(readFileSync4(file, "utf8"));
+  if (parsed === void 0 || typeof parsed.name !== "string") {
+    throw new Error("mcp catalog manifest rejected");
+  }
+  return parsed;
+}
+function load_catalog() {
+  if (cached !== void 0) {
+    return cached;
+  }
+  const manifests = [];
+  for (const name of readdirSync3(catalog_dir())) {
+    const file = path9.join(catalog_dir(), name, "manifest.json");
+    if (existsSync2(file) === true) {
+      manifests.push(read_manifest(file));
+    }
+  }
+  cached = manifests;
+  return cached;
+}
+function catalog_by_name(name) {
+  return load_catalog().find((entry) => entry.name === name);
+}
+
+// src/mcp/mcp_refuse.ts
+import path10 from "path";
+var SHELL = /[;&|`$<>]/;
+var DOWNLOADERS = /* @__PURE__ */ new Set(["npx", "npm", "bunx", "uvx", "curl", "wget"]);
+function refuse_stdio_command(command) {
+  if (command.includes("://") === true) {
+    return "refused url; only a local binary is allowed";
+  }
+  if (SHELL.test(command) === true) {
+    return "refused shell metacharacters in mcp command";
+  }
+  if (command.length === 0 || command.trim() !== command || /\s/.test(command) === true) {
+    return "refused mcp command";
+  }
+  const base = path10.basename(command);
+  if (DOWNLOADERS.has(base) === true) {
+    return `refused download command '${base}'`;
+  }
+  return void 0;
+}
+function refuse_stdio_arg(arg) {
+  if (arg.includes("://") === true) {
+    return "refused url in mcp args";
+  }
+  if (SHELL.test(arg) === true) {
+    return "refused shell metacharacters in mcp args";
+  }
+  return void 0;
+}
+
+// src/mcp/mcp_url.ts
+function refuse_http_url(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "refused mcp url";
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return "refused mcp url";
+  }
+  if (parsed.username.length > 0 || parsed.password.length > 0) {
+    return "refused mcp url credentials";
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host !== "127.0.0.1" && host !== "localhost") {
+    return "refused mcp url; loopback only";
+  }
+  return void 0;
+}
+
+// src/mcp/mcp_pin.ts
+function refuse_catalog_stdio(name, command, args) {
+  const pin = catalog_by_name(name);
+  if (pin?.command_basename === void 0) {
+    return void 0;
+  }
+  if (path11.basename(command) !== pin.command_basename) {
+    return `refused command basename '${path11.basename(command)}'; only '${pin.command_basename}' is allowed`;
+  }
+  const prefix = pin.args_prefix ?? [];
+  if (args.length !== prefix.length + 1) {
+    return `refused ${name} args; expected ${prefix.join(" ")} <project>`;
+  }
+  for (let index = 0; index < prefix.length; index += 1) {
+    if (args[index] !== prefix[index]) {
+      return `refused ${name} args; expected ${prefix.join(" ")} <project>`;
+    }
+  }
+  const project = args[prefix.length];
+  if (project === void 0 || project.length === 0 || project.includes("://") === true) {
+    return "refused project path; pass a local project directory";
+  }
+  return void 0;
+}
+function refuse_arg_list(args) {
+  for (const arg of args) {
+    const refused = refuse_stdio_arg(arg);
+    if (refused !== void 0) {
+      return refused;
+    }
+  }
+  return void 0;
+}
+function refuse_mcp_entry(name, entry) {
+  if (typeof entry.url === "string") {
+    return refuse_http_url(entry.url);
+  }
+  if (typeof entry.command !== "string") {
+    return "refused mcp entry";
+  }
+  const args = entry.args ?? [];
+  return refuse_stdio_command(entry.command) ?? refuse_catalog_stdio(name, entry.command, args) ?? refuse_arg_list(args);
+}
+
 // src/agent/config.ts
 var gateway_schema = z.object({
   platforms: z.array(z.enum(["webhook", "telegram", "discord", "twitch"])).default([]),
   /** Env-var names that hold tokens. Never store the secrets themselves. */
   token_envs: z.record(z.string(), z.string().regex(ENV_VAR_NAME, "invalid env var name")).default({})
 }).optional();
+var stdio_mcp_schema = z.object({
+  enabled: z.boolean().default(false),
+  command: z.string().min(1),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string().regex(ENV_VAR_NAME, "invalid env var name"), z.string()).optional()
+}).strict();
+var http_mcp_schema = z.object({
+  enabled: z.boolean().default(false),
+  url: z.string().min(1)
+}).strict();
+var mcp_server_schema = z.union([stdio_mcp_schema, http_mcp_schema]);
+var SERVER_NAME = /^[a-z][a-z0-9_]*$/;
+var mcp_servers_schema = z.record(z.string(), mcp_server_schema).superRefine((servers, ctx) => {
+  for (const [name, entry] of Object.entries(servers)) {
+    if (SERVER_NAME.test(name) === false) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [name],
+        message: "mcp server name must be snake_case"
+      });
+    }
+    const refused = refuse_mcp_entry(name, entry);
+    if (refused !== void 0) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: [name], message: refused });
+    }
+  }
+}).optional();
 var provider_schema = z.object({
   kind: z.enum(["openai_compat", "anthropic", "ollama"]),
   name: z.string().min(1),
@@ -1947,7 +2113,9 @@ var agent_config_schema = z.object({
   plugins: z.array(z.string()).default([]),
   gateway: gateway_schema,
   log_level: z.enum(["debug", "info", "warn", "error"]).default("info"),
-  theme: z.string().min(1).default("lich")
+  theme: z.string().min(1).default("lich"),
+  /** Named MCP servers. Each entry is stdio or loopback http. Default off. */
+  mcp_servers: mcp_servers_schema
 }).transform((config) => {
   const work_dir = config.work_dir ?? process.cwd();
   return {
@@ -1968,6 +2136,18 @@ function freeze_config(config) {
     Object.freeze(config.gateway.token_envs);
     Object.freeze(config.gateway);
   }
+  if (config.mcp_servers !== void 0) {
+    for (const entry of Object.values(config.mcp_servers)) {
+      if ("args" in entry) {
+        Object.freeze(entry.args);
+      }
+      if ("env" in entry && entry.env !== void 0) {
+        Object.freeze(entry.env);
+      }
+      Object.freeze(entry);
+    }
+    Object.freeze(config.mcp_servers);
+  }
   return config;
 }
 function parse_agent_config(raw) {
@@ -2000,15 +2180,543 @@ var AgentEmitter = class {
   }
 };
 
-// src/plugins/builtin/gatekeeper.plugin.ts
+// src/mcp/mcp_http.ts
+async function post_rpc(url, fetch_fn, body) {
+  const response = await fetch_fn(url, {
+    method: "POST",
+    redirect: "error",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify(body)
+  });
+  const parsed = await response.json();
+  if (parsed.error !== void 0) {
+    const detail = parsed.error.message;
+    throw new Error(typeof detail === "string" && detail.length > 0 ? detail : "mcp error");
+  }
+  return parsed.result;
+}
+function http_pipe(url, fetch_fn) {
+  let next_id = 1;
+  return {
+    request(method, params) {
+      const id = next_id;
+      next_id += 1;
+      return post_rpc(url, fetch_fn, { jsonrpc: "2.0", id, method, params });
+    },
+    notify(method) {
+      void fetch_fn(url, {
+        method: "POST",
+        redirect: "error",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", method })
+      }).catch(() => void 0);
+    },
+    close() {
+      return void 0;
+    }
+  };
+}
+
+// src/mcp/mcp_plan.ts
+import { existsSync as existsSync3 } from "fs";
+import path12 from "path";
+function find_on_path(command, env_path) {
+  if (env_path === void 0 || env_path.length === 0) {
+    return void 0;
+  }
+  for (const dir of env_path.split(path12.delimiter)) {
+    if (dir.length === 0) {
+      continue;
+    }
+    const candidate = path12.join(dir, command);
+    if (existsSync3(candidate) === true) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function locate(command, env_path) {
+  if (command.includes("/") === true || command.includes("\\") === true) {
+    return existsSync3(command) === true ? command : void 0;
+  }
+  return find_on_path(command, env_path);
+}
+function plan_stdio(name, command, args, env_path) {
+  const refused = refuse_mcp_entry(name, { command, args });
+  if (refused !== void 0) {
+    return refused;
+  }
+  const binary = locate(command, env_path);
+  if (binary === void 0) {
+    return catalog_by_name(name)?.missing_hint ?? "mcp command not found";
+  }
+  return { command: binary, args };
+}
+
+// src/mcp/mcp_pipe.ts
+var SKIP_LIMIT = 32;
+function parse_rpc_line(line) {
+  const parsed = safe_json_parse(line);
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  return parsed;
+}
+async function read_id(child, id) {
+  for (let skipped = 0; skipped < SKIP_LIMIT; skipped += 1) {
+    const line = await child.read_line();
+    const failure = child.failed();
+    if (failure !== void 0) {
+      throw new Error(failure);
+    }
+    if (line === void 0) {
+      throw new Error("mcp closed the pipe");
+    }
+    const parsed = parse_rpc_line(line);
+    if (parsed === void 0 || parsed.id !== id) {
+      continue;
+    }
+    if (parsed.error !== void 0) {
+      const detail = parsed.error.message;
+      throw new Error(typeof detail === "string" && detail.length > 0 ? detail : "mcp error");
+    }
+    return parsed.result;
+  }
+  throw new Error("mcp sent no matching response");
+}
+function stdio_pipe(child) {
+  let next_id = 1;
+  return {
+    request(method, params) {
+      const id = next_id;
+      next_id += 1;
+      child.write_line(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+      return read_id(child, id);
+    },
+    notify(method) {
+      child.write_line(JSON.stringify({ jsonrpc: "2.0", method }));
+    },
+    close() {
+      child.stop();
+    }
+  };
+}
+
+// src/mcp/mcp_names.ts
+function mcp_tool_name(server, tool) {
+  return `mcp_${sanitize(server)}_${sanitize(tool)}`;
+}
+function sanitize(value) {
+  return value.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+// src/mcp/mcp_register.ts
+function name_allowed(enabled, name) {
+  if (enabled === "all") {
+    return true;
+  }
+  return enabled.includes(name);
+}
+function run_call(session, wire_name, args, context) {
+  return capture_errors(async () => {
+    if (context.signal?.aborted === true) {
+      throw new Error("cancelled");
+    }
+    return { ok: true, output: await session.call_tool(wire_name, args) };
+  });
+}
+function tool_for(registered, wire_name, spec, session) {
+  return {
+    name: registered,
+    description: spec.description,
+    parameters: spec.parameters,
+    timeout_ms: 12e4,
+    execute: (args, context) => run_call(session, wire_name, args, context)
+  };
+}
+function register_listed(registry, server, listed, enabled, session) {
+  const excluded = new Set(catalog_by_name(server)?.exclude_tools ?? []);
+  for (const spec of listed) {
+    if (excluded.has(spec.name) === true) {
+      continue;
+    }
+    const registered = mcp_tool_name(server, spec.name);
+    if (name_allowed(enabled, registered) === false || registry.has(registered) === true) {
+      continue;
+    }
+    registry.register(tool_for(registered, spec.name, spec, session));
+  }
+}
+
+// src/mcp/mcp_handshake.ts
+var PROTOCOL_VERSION = "2024-11-05";
+function init_params() {
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: "lich", version: "1" }
+  };
+}
+function assert_handshake(result) {
+  if (typeof result !== "object" || result === null) {
+    throw new Error("mcp handshake rejected");
+  }
+  const body = result;
+  if (typeof body.protocolVersion !== "string" || body.protocolVersion.length === 0) {
+    throw new Error("mcp handshake rejected");
+  }
+  if (typeof body.serverInfo?.name !== "string" || body.serverInfo.name.length === 0) {
+    throw new Error("mcp handshake rejected");
+  }
+}
+
+// src/mcp/mcp_content.ts
+function content_text(result) {
+  if (typeof result !== "object" || result === null) {
+    return "";
+  }
+  const body = result;
+  const parts = [];
+  if (Array.isArray(body.content) === true) {
+    for (const item of body.content) {
+      if (typeof item !== "object" || item === null) {
+        continue;
+      }
+      const chunk = item;
+      if (chunk.type === "text" && typeof chunk.text === "string") {
+        parts.push(chunk.text);
+      }
+      if (chunk.type === "image") {
+        parts.push("[image omitted]");
+      }
+    }
+  }
+  const text = parts.join("\n");
+  if (body.isError === true) {
+    throw new Error(text.length > 0 ? text : "mcp tool failed");
+  }
+  return text;
+}
+
+// src/mcp/mcp_result.ts
+function tool_schema(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return { type: "object" };
+  }
+  const body = raw;
+  const schema = { type: "object" };
+  if (typeof body.properties === "object" && body.properties !== null) {
+    schema.properties = body.properties;
+  }
+  if (Array.isArray(body.required) === true) {
+    schema.required = body.required.filter((item) => typeof item === "string");
+  }
+  if (typeof body.additionalProperties === "boolean") {
+    schema.additionalProperties = body.additionalProperties;
+  }
+  return schema;
+}
+function parse_tools(result) {
+  if (typeof result !== "object" || result === null || Array.isArray(result.tools) === false) {
+    throw new Error("mcp tools/list rejected");
+  }
+  const tools = [];
+  for (const item of result.tools) {
+    if (typeof item !== "object" || item === null) {
+      continue;
+    }
+    const tool = item;
+    if (typeof tool.name !== "string" || tool.name.length === 0) {
+      continue;
+    }
+    tools.push({
+      name: tool.name,
+      description: typeof tool.description === "string" ? tool.description : tool.name,
+      parameters: tool_schema(tool.inputSchema)
+    });
+  }
+  return tools;
+}
+
+// src/mcp/mcp_session.ts
+var McpSession = class {
+  constructor(pipe) {
+    this.pipe = pipe;
+  }
+  pipe;
+  ready_done = false;
+  closed = false;
+  close() {
+    if (this.closed === true) {
+      return;
+    }
+    this.closed = true;
+    this.pipe.close();
+  }
+  async list_tools() {
+    await this.ensure_ready();
+    return parse_tools(await this.pipe.request("tools/list", {}));
+  }
+  async call_tool(name, args) {
+    await this.ensure_ready();
+    return content_text(await this.pipe.request("tools/call", { name, arguments: args }));
+  }
+  async ensure_ready() {
+    if (this.ready_done === true) {
+      return;
+    }
+    try {
+      assert_handshake(await this.pipe.request("initialize", init_params()));
+      this.pipe.notify("notifications/initialized");
+      this.ready_done = true;
+    } catch (error) {
+      this.close();
+      throw error;
+    }
+  }
+};
+
+// src/mcp/mcp_lines.ts
+function create_line_queue() {
+  const pending = [];
+  const waiters = [];
+  let closed = false;
+  return {
+    push(line) {
+      const waiter = waiters.shift();
+      if (waiter !== void 0) {
+        waiter(line);
+        return;
+      }
+      pending.push(line);
+    },
+    close() {
+      closed = true;
+      for (const waiter of waiters.splice(0)) {
+        waiter(void 0);
+      }
+    },
+    read() {
+      const next = pending.shift();
+      if (next !== void 0) {
+        return Promise.resolve(next);
+      }
+      if (closed === true) {
+        return Promise.resolve(void 0);
+      }
+      return new Promise((resolve) => {
+        waiters.push(resolve);
+      });
+    }
+  };
+}
+
+// src/mcp/mcp_child.ts
+function spawn_failure(code) {
+  if (code === "ENOENT") {
+    return "mcp command not found";
+  }
+  return "mcp spawn failed";
+}
+function failed_child(message) {
+  return {
+    write_line() {
+      return void 0;
+    },
+    read_line() {
+      return Promise.resolve(void 0);
+    },
+    stop() {
+      return void 0;
+    },
+    failed() {
+      return message;
+    }
+  };
+}
+
+// src/mcp/mcp_stdio_bun.ts
+async function pump_stdout(stream, queue) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const next = await reader.read();
+    if (next.done === true) {
+      if (buffer.length > 0) {
+        queue.push(buffer);
+      }
+      queue.close();
+      return;
+    }
+    buffer += decoder.decode(next.value, { stream: true });
+    const parts = buffer.split("\n");
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      queue.push(part);
+    }
+  }
+}
+async function drain_stderr(stream) {
+  const reader = stream.getReader();
+  while ((await reader.read()).done === false) {
+    continue;
+  }
+}
+function bun_line_child(command, args, env) {
+  const queue = create_line_queue();
+  try {
+    const options = { stdin: "pipe", stdout: "pipe", stderr: "pipe" };
+    const child = env === void 0 ? Bun.spawn([command, ...args], options) : Bun.spawn([command, ...args], { ...options, env });
+    void pump_stdout(child.stdout, queue);
+    void drain_stderr(child.stderr);
+    return {
+      write_line(line) {
+        child.stdin.write(`${line}
+`);
+        void child.stdin.flush();
+      },
+      read_line() {
+        return queue.read();
+      },
+      stop() {
+        child.kill();
+      },
+      failed() {
+        return void 0;
+      }
+    };
+  } catch (error) {
+    const coded = error;
+    return failed_child(spawn_failure(coded.code));
+  }
+}
+
+// src/mcp/mcp_stdio_node.ts
 import { spawn as spawn3 } from "child_process";
+import { createInterface } from "readline";
+function child_env(extra) {
+  if (extra === void 0) {
+    return void 0;
+  }
+  const merged = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") {
+      merged[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    merged[key] = value;
+  }
+  return merged;
+}
+function node_line_child(command, args, env) {
+  const queue = create_line_queue();
+  let failure;
+  const child = spawn3(command, [...args], { stdio: ["pipe", "pipe", "pipe"], env: child_env(env) });
+  const reader = createInterface({ input: child.stdout });
+  reader.on("line", (line) => {
+    queue.push(line);
+  });
+  reader.on("close", () => {
+    queue.close();
+  });
+  child.stderr?.resume();
+  child.on("error", (error) => {
+    failure = spawn_failure(error.code);
+    queue.close();
+  });
+  return {
+    write_line(line) {
+      child.stdin?.write(`${line}
+`);
+    },
+    read_line() {
+      return queue.read();
+    },
+    stop() {
+      child.kill();
+    },
+    failed() {
+      return failure;
+    }
+  };
+}
+
+// src/mcp/mcp_stdio.ts
+function running_under_bun() {
+  return process.versions.bun !== void 0;
+}
+function default_line_spawner(command, args, env) {
+  if (running_under_bun() === true) {
+    return bun_line_child(command, args, env);
+  }
+  return node_line_child(command, args, env);
+}
+
+// src/mcp/mcp_attach.ts
+async function open_and_register(registry, name, enabled, session) {
+  try {
+    register_listed(registry, name, await session.list_tools(), enabled, session);
+  } catch (error) {
+    session.close();
+    const message = error instanceof Error ? error.message : "mcp skipped";
+    logger.warn(`mcp ${name} skipped: ${message}`);
+  }
+}
+async function attach_stdio(registry, name, entry, config, runtime) {
+  const planned = plan_stdio(name, entry.command, entry.args, runtime?.env_path ?? process.env.PATH);
+  if (typeof planned === "string") {
+    logger.warn(`mcp ${name} skipped: ${planned}`);
+    return;
+  }
+  const spawn5 = runtime?.spawn ?? default_line_spawner;
+  const session = new McpSession(stdio_pipe(spawn5(planned.command, planned.args, entry.env)));
+  await open_and_register(registry, name, config.tools_enabled, session);
+}
+async function attach_http(registry, name, url, config, runtime) {
+  const session = new McpSession(http_pipe(url, runtime?.fetch_fn ?? fetch));
+  await open_and_register(registry, name, config.tools_enabled, session);
+}
+
+// src/mcp/mcp_tools.ts
+function allowlist_wants_mcp(enabled) {
+  if (enabled === "all") {
+    return true;
+  }
+  return enabled.some((name) => name.startsWith("mcp_") === true);
+}
+async function attach_enabled_mcp_tools(registry, config, runtime) {
+  const servers = config.mcp_servers;
+  if (servers === void 0 || allowlist_wants_mcp(config.tools_enabled) === false) {
+    return;
+  }
+  for (const [name, entry] of Object.entries(servers)) {
+    if (entry.enabled !== true) {
+      continue;
+    }
+    try {
+      if ("url" in entry) {
+        await attach_http(registry, name, entry.url, config, runtime);
+        continue;
+      }
+      await attach_stdio(registry, name, entry, config, runtime);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "mcp skipped";
+      logger.warn(`mcp ${name} skipped: ${message}`);
+    }
+  }
+}
+
+// src/plugins/builtin/gatekeeper.plugin.ts
+import { spawn as spawn4 } from "child_process";
 import { statSync as statSync2 } from "fs";
-import path9 from "path";
+import path13 from "path";
 var HOOKS_OFF = ["-c", "core.hooksPath=/dev/null"];
 var PATHSPEC_MAGIC = /[:*?[]/;
 var SECRET_BASENAMES = [".env", ".env.local", "id_rsa"];
 function is_secret_path(file_path) {
-  const base = path9.basename(file_path);
+  const base = path13.basename(file_path);
   if (SECRET_BASENAMES.includes(base) === true) {
     return true;
   }
@@ -2035,7 +2743,7 @@ function matches_git_denylist(command) {
 }
 function run_git(args, work_dir, signal) {
   return new Promise((resolve) => {
-    const child = spawn3("git", args, { cwd: work_dir, env: process.env });
+    const child = spawn4("git", args, { cwd: work_dir, env: process.env });
     let settled = false;
     let out = "";
     const on_abort = () => {
@@ -2086,7 +2794,7 @@ function invalid_commit_path(raw, work_dir) {
     return `invalid_path: ${raw}`;
   }
   const resolved = resolve_safe_path(work_dir, raw);
-  if (resolved === path9.resolve(work_dir)) {
+  if (resolved === path13.resolve(work_dir)) {
     return `invalid_path: ${raw} resolves to work_dir`;
   }
   if (is_secret_path(raw) === true) {
@@ -3388,7 +4096,7 @@ function to_provider_error(error, fallback_name) {
 
 // src/session/store.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
-import path10 from "path";
+import path14 from "path";
 var counter_state = { value: 0 };
 function slugify_label(label) {
   const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -3399,7 +4107,7 @@ async function open_session(dir, label) {
   counter_state.value += 1;
   const label_part = label === void 0 ? "" : slugify_label(label);
   const id = `${Date.now().toString(36)}-${counter_state.value}${label_part}`;
-  const file_path = path10.join(dir, `${id}.jsonl`);
+  const file_path = path14.join(dir, `${id}.jsonl`);
   return {
     id,
     path: file_path,
@@ -3680,8 +4388,11 @@ var Agent = class {
   registry;
   executor;
   hook_runner;
-  constructor(config, plugins = []) {
+  mcp_runtime;
+  mcp_attached = false;
+  constructor(config, plugins = [], runtime) {
     this.config = config;
+    this.mcp_runtime = runtime?.mcp;
     this.events = new AgentEmitter();
     this.router = new ProviderRouter(config.providers);
     const base_registry = new ToolRegistry();
@@ -3705,6 +4416,7 @@ var Agent = class {
     }
   }
   async run(options) {
+    await this.attach_mcp_once();
     const usage_total = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
     const stop_collecting = this.events.on(collect_usage(usage_total));
     await this.call_plugin_run_start(options.input);
@@ -3732,6 +4444,14 @@ var Agent = class {
     const full_messages = [...options.history ?? [], ...outcome.messages];
     return { outcome, messages: full_messages, usage_total, session_path };
   }
+  /** tools/list once, before the model sees definitions. Empty allowlists never connect. */
+  async attach_mcp_once() {
+    if (this.mcp_attached === true) {
+      return;
+    }
+    this.mcp_attached = true;
+    await attach_enabled_mcp_tools(this.registry, this.config, this.mcp_runtime);
+  }
   /** Per-run deps: the built-once ToolContext threads through every tool execution. */
   loop_deps(tool_context) {
     return {
@@ -3801,6 +4521,8 @@ export {
   truncate_text,
   logger,
   register_builtin_tools,
+  catalog_by_name,
+  refuse_mcp_entry,
   ToolRegistry,
   ToolExecutor,
   HookedToolRunner,
@@ -3819,4 +4541,4 @@ export {
   create_agent_with_plugins,
   run_agent
 };
-//# sourceMappingURL=chunk-7HLVKVIG.js.map
+//# sourceMappingURL=chunk-QVJCIZIF.js.map