@moikapy/lich 0.6.0 → 0.7.1

package/dist/cli.js

@@ -2,20 +2,22 @@
 import {
   load_theme,
   notice_flavor
-} from "./chunk-JC2G3XH2.js";
+} from "./chunk-CVX7LZWC.js";
 import {
-  LICH_VERSION
-} from "./chunk-6M6OAQGN.js";
+  LICH_VERSION,
+  catalog_client_entry
+} from "./chunk-PZNYVGD4.js";
 import {
   DEFAULT_GATEWAY_TOKEN_ENVS,
   create_agent_with_plugins,
   is_env_var_name,
   parse_agent_config,
+  refuse_mcp_entry,
   safe_json_parse
-} from "./chunk-7HLVKVIG.js";
+} from "./chunk-WNFBIX4E.js";
 
 // src/cli.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2, realpathSync } from "fs";
 import { createInterface } from "readline";
 import path4 from "path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -89,22 +91,26 @@ function starter_config_object() {
   }
   return parsed;
 }
-function write_lich_config(work_dir, config) {
+function write_lich_config(work_dir, config, update = false) {
   ensure_lich_config_dir(work_dir);
   const file = project_config_path(work_dir);
-  if (existsSync(file) === true) {
+  if (existsSync(file) === true && update !== true) {
     return already_exists(file);
   }
   try {
     writeFileSync(file, `${JSON.stringify(config, null, 2)}
-`, { encoding: "utf8", flag: "wx" });
+`, {
+      encoding: "utf8",
+      flag: update === true ? "w" : "wx"
+    });
   } catch (error) {
-    if (is_eexist(error) === true) {
+    if (update !== true && is_eexist(error) === true) {
       return already_exists(file);
     }
     throw error;
   }
-  return { path: file, written: true, message: `wrote ${file}` };
+  const verb = update === true ? "updated" : "wrote";
+  return { path: file, written: true, message: `${verb} ${file}` };
 }
 function already_exists(file) {
   return {
@@ -117,9 +123,211 @@ function is_eexist(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
 
+// src/cli_mcp_add.ts
+var SERVER_NAME = /^[a-z][a-z0-9_]*$/;
+function require_server_name(name, action) {
+  if (name === void 0 || SERVER_NAME.test(name) === false) {
+    throw new Error(`mcp ${action} requires a snake_case name`);
+  }
+  return name;
+}
+function entry_from_flags(name, flags) {
+  if (flags.command !== void 0 && flags.url !== void 0) {
+    throw new Error("mcp add accepts --command or --url, not both");
+  }
+  if (flags.url !== void 0) {
+    if (flags.args.length > 0) {
+      throw new Error("mcp add --url does not take --arg");
+    }
+    return { enabled: false, url: flags.url };
+  }
+  if (flags.command === void 0) {
+    throw new Error("mcp add needs a catalog entry, --command, or --url");
+  }
+  return { enabled: false, command: flags.command, args: [...flags.args] };
+}
+function entry_from_catalog(name, flags) {
+  const substitutes = {};
+  if (flags.project_path !== void 0) {
+    substitutes["project_path"] = flags.project_path;
+  }
+  const built = catalog_client_entry(name, substitutes);
+  if (typeof built === "string") {
+    throw new Error(built);
+  }
+  return built;
+}
+function build_mcp_entry(name, flags) {
+  const entry = flags.command !== void 0 || flags.url !== void 0 ? entry_from_flags(name, flags) : entry_from_catalog(name, flags);
+  const refused = refuse_mcp_entry(name, {
+    command: typeof entry["command"] === "string" ? entry["command"] : void 0,
+    args: Array.isArray(entry["args"]) ? entry["args"].filter((arg) => typeof arg === "string") : [],
+    url: typeof entry["url"] === "string" ? entry["url"] : void 0
+  });
+  if (refused !== void 0) {
+    throw new Error(refused);
+  }
+  return entry;
+}
+
+// src/cli_mcp_store.ts
+import { existsSync as existsSync2 } from "fs";
+function read_work_config(work_dir) {
+  const file = project_config_path(work_dir);
+  if (existsSync2(file) === false) {
+    return {};
+  }
+  return load_config(file) ?? {};
+}
+function mcp_servers_of(config) {
+  const raw = config["mcp_servers"];
+  if (raw === void 0) {
+    return {};
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw) === true) {
+    throw new Error("mcp_servers must be an object");
+  }
+  const servers = {};
+  for (const [name, entry] of Object.entries(raw)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry) === true) {
+      throw new Error(`mcp server '${name}' is not an object`);
+    }
+    servers[name] = { ...entry };
+  }
+  return servers;
+}
+function save_mcp_servers(work_dir, current, servers) {
+  const next = { ...current };
+  if (Object.keys(servers).length === 0) {
+    delete next["mcp_servers"];
+  } else {
+    next["mcp_servers"] = servers;
+  }
+  const result = write_lich_config(work_dir, next, true);
+  if (result.written !== true) {
+    throw new Error("mcp config was not written");
+  }
+}
+function list_mcp_lines(servers) {
+  const lines = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    const transport = typeof entry["url"] === "string" ? "http" : "stdio";
+    const enabled = entry["enabled"] === true ? "true" : "false";
+    lines.push(`${name} ${transport} ${enabled}`);
+  }
+  return lines;
+}
+
+// src/cli_mcp_edit.ts
+function require_entry(servers, name) {
+  const entry = servers[name];
+  if (entry === void 0) {
+    throw new Error(`mcp server '${name}' not found`);
+  }
+  return entry;
+}
+function set_mcp_enabled(work_dir, name, enabled) {
+  const server = require_server_name(name, enabled === true ? "enable" : "disable");
+  const current = read_work_config(work_dir);
+  const servers = mcp_servers_of(current);
+  const entry = require_entry(servers, server);
+  servers[server] = { ...entry, enabled };
+  save_mcp_servers(work_dir, current, servers);
+  return enabled === true ? `enabled ${server}` : `disabled ${server}`;
+}
+function remove_mcp_server(work_dir, name) {
+  const server = require_server_name(name, "remove");
+  const current = read_work_config(work_dir);
+  const servers = mcp_servers_of(current);
+  require_entry(servers, server);
+  delete servers[server];
+  save_mcp_servers(work_dir, current, servers);
+  return `removed ${server}`;
+}
+
+// src/cli_mcp.ts
+function write_line(line) {
+  process.stdout.write(`${line}
+`);
+}
+function add_mcp_server(work_dir, name, flags) {
+  const server = require_server_name(name, "add");
+  const current = read_work_config(work_dir);
+  const servers = mcp_servers_of(current);
+  if (servers[server] !== void 0) {
+    throw new Error(`mcp server '${server}' already exists`);
+  }
+  servers[server] = build_mcp_entry(server, flags);
+  save_mcp_servers(work_dir, current, servers);
+  return `added ${server} disabled`;
+}
+function run_mcp(work_dir, positionals, flags) {
+  const action = positionals[1];
+  if (positionals.length > 3) {
+    throw new Error("mcp takes one name");
+  }
+  if (action === "list") {
+    if (positionals[2] !== void 0) {
+      throw new Error("mcp list takes no name");
+    }
+    const lines = list_mcp_lines(mcp_servers_of(read_work_config(work_dir)));
+    if (lines.length > 0) {
+      process.stdout.write(`${lines.join("\n")}
+`);
+    }
+    return 0;
+  }
+  if (action === "add") {
+    write_line(add_mcp_server(work_dir, positionals[2], flags));
+    return 0;
+  }
+  if (action === "enable" || action === "disable") {
+    write_line(set_mcp_enabled(work_dir, positionals[2], action === "enable"));
+    return 0;
+  }
+  if (action === "remove") {
+    write_line(remove_mcp_server(work_dir, positionals[2]));
+    return 0;
+  }
+  throw new Error("mcp requires list, add, enable, disable, or remove");
+}
+
+// src/cli_mcp_flags.ts
+function empty_mcp_flags() {
+  return { args: [] };
+}
+function take_mcp_flag(argv, index, flags) {
+  const arg = argv[index];
+  if (arg === "--arg") {
+    const value2 = argv[index + 1];
+    if (value2 === void 0) {
+      throw new Error("--arg requires a value");
+    }
+    flags.args.push(value2);
+    return index + 1;
+  }
+  if (arg !== "--command" && arg !== "--url" && arg !== "--project-path") {
+    return void 0;
+  }
+  const value = argv[index + 1];
+  if (value === void 0 || value.startsWith("--") === true) {
+    throw new Error(`${arg} requires a value`);
+  }
+  if (arg === "--command") {
+    flags.command = value;
+  }
+  if (arg === "--url") {
+    flags.url = value;
+  }
+  if (arg === "--project-path") {
+    flags.project_path = value;
+  }
+  return index + 1;
+}
+
 // src/cli_update.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import path2 from "path";
 var PACKAGE_NAME = "@moikapy/lich";
 var VIEW_ARGS = ["view", PACKAGE_NAME, "version"];
@@ -351,7 +559,7 @@ function bun_command_runner(command, args) {
 async function run_update(module_path) {
   return run_lich_update({
     installed_version: LICH_VERSION,
-    install_kind: detect_install_kind(module_path, process.env, (dir) => existsSync2(path2.join(dir, ".git"))),
+    install_kind: detect_install_kind(module_path, process.env, (dir) => existsSync3(path2.join(dir, ".git"))),
     run_command: default_command_runner,
     write_stdout: (text) => {
       process.stdout.write(text);
@@ -607,6 +815,9 @@ function usage_text() {
     "  lich gateway <plat..>  messaging gateway (webhook|telegram|discord|twitch)",
     "  lich config            print a starter config template (save as .lich/config.json)",
     "  lich update            install a newer @moikapy/lich from npm, if one exists",
+    "  lich mcp list          list mcp servers in .lich/config.json",
+    "  lich mcp add <name>    add a catalog or --command/--url server (disabled)",
+    "  lich mcp enable <name> / disable <name> / remove <name>",
     "  lich --help            show this help",
     "  lich --version         print version",
     "",
@@ -621,7 +832,11 @@ function usage_text() {
     "  --system-prompt <s>    system prompt override",
     "  --session-dir <path>   session transcript directory",
     "  --log-level <level>    debug | info | warn | error",
-    "  --theme <name>         display theme (default lich; files in ~/.lich/themes)"
+    "  --theme <name>         display theme (default lich; files in ~/.lich/themes)",
+    "  --command <bin>        mcp add: local stdio binary",
+    "  --arg <value>          mcp add: repeatable stdio arg (may start with --)",
+    "  --url <url>            mcp add: loopback http url",
+    "  --project-path <path>  mcp add: catalog ${project_path} substitute"
   ].join("\n");
 }
 function error_message(error) {
@@ -640,7 +855,8 @@ function error_for_mode(mode, base_message) {
   return base_message;
 }
 function parse_args(argv) {
-  const options = { overrides: {}, positionals: [] };
+  const options = { overrides: {}, positionals: [], mcp_flags: empty_mcp_flags() };
+  const mcp = argv.includes("mcp");
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === void 0) {
@@ -663,6 +879,13 @@ function parse_args(argv) {
       index += 1;
       continue;
     }
+    if (mcp === true) {
+      const consumed = take_mcp_flag(argv, index, options.mcp_flags);
+      if (consumed !== void 0) {
+        index = consumed;
+        continue;
+      }
+    }
     const override_key = FLAG_KEYS[arg];
     if (override_key === void 0) {
       if (arg.startsWith("--") === true) {
@@ -760,7 +983,7 @@ function build_config(options) {
   apply_overrides(base, options.overrides);
   const providers = base["providers"];
   if (Array.isArray(providers) === false || providers.length === 0) {
-    throw new Error("no model configured: set LICH_MODEL, pass --model, or create .lich/config.json (`lich config` prints a template)");
+    base["providers"] = [env_provider(options.overrides)];
   }
   return parse_agent_config(base);
 }
@@ -798,6 +1021,7 @@ async function run_one_shot(config, input) {
     result = await agent.run({ input });
   } finally {
     stop_progress();
+    agent.close();
   }
   const final = result.outcome.final;
   if (final !== void 0 && final.content.length > 0) {
@@ -868,6 +1092,7 @@ async function run_chat(config) {
     }
   } finally {
     rl.close();
+    agent.close();
   }
 }
 function model_hint(options) {
@@ -955,7 +1180,7 @@ function run_init(options) {
   return 0;
 }
 async function run_tui_entry(config) {
-  const { run_tui } = await import("./tui-LOUJVZ6A.js");
+  const { run_tui } = await import("./tui-MEJGEILU.js");
   return run_tui(config);
 }
 function gateway_platforms(config, cli_platforms) {
@@ -966,7 +1191,7 @@ function gateway_platforms(config, cli_platforms) {
   return configured.length === 0 ? ["webhook"] : configured;
 }
 async function run_gateway_entry(config, platforms) {
-  const { run_gateway } = await import("./gateway-RJFZJEUZ.js");
+  const { run_gateway } = await import("./gateway-44QTIJTJ.js");
   return run_gateway(config, gateway_platforms(config, platforms));
 }
 function is_cli_entry(input) {
@@ -994,7 +1219,7 @@ function node_entry_matches(module_url, entry) {
   return same_real_file(fileURLToPath(module_url), resolved);
 }
 function same_real_file(left, right) {
-  if (existsSync3(left) === false || existsSync3(right) === false) {
+  if (existsSync4(left) === false || existsSync4(right) === false) {
     return false;
   }
   return realpathSync(left) === realpathSync(right);
@@ -1023,6 +1248,9 @@ async function run_cli(argv) {
 `);
     return 0;
   }
+  if (first === "mcp") {
+    return run_mcp(work_dir_of(options), options.positionals, options.mcp_flags);
+  }
   if (first === "update") {
     if (options.positionals.length > 1) {
       throw new Error("update takes no arguments");