@moikapy/lich 0.4.0 → 0.5.1

package/dist/cli.js

@@ -1,21 +1,23 @@
 #!/usr/bin/env node
 import {
   LICH_VERSION
-} from "./chunk-ZVK3MUPC.js";
+} from "./chunk-6M6OAQGN.js";
 import {
-  create_agent,
+  DEFAULT_GATEWAY_TOKEN_ENVS,
+  create_agent_with_plugins,
+  is_env_var_name,
   parse_agent_config,
   safe_json_parse
-} from "./chunk-MLFJW4JU.js";
+} from "./chunk-CV2YH3FH.js";
 
 // src/cli.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync } from "fs";
 import { createInterface } from "readline";
-import path2 from "path";
-import { pathToFileURL } from "url";
+import path4 from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 
 // src/cli_config.ts
-import { existsSync, mkdirSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import path from "path";
 var LICH_DIRNAME = ".lich";
@@ -34,12 +36,7 @@ function find_config_file(explicit) {
     }
     return explicit;
   }
-  for (const candidate of config_search_paths()) {
-    if (existsSync(candidate) === true) {
-      return candidate;
-    }
-  }
-  return void 0;
+  return existing_config_path(process.cwd());
 }
 function load_config(explicit) {
   const found = find_config_file(explicit);
@@ -65,6 +62,509 @@ function config_template() {
   }
   return JSON.stringify({ providers: [provider], max_turns: 25 }, null, 2);
 }
+function ensure_lich_config_dir(work_dir) {
+  const dir = path.resolve(work_dir, LICH_DIRNAME);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function project_config_path(work_dir) {
+  return path.resolve(work_dir, CONFIG_RELPATH);
+}
+function existing_config_path(work_dir) {
+  for (const candidate of config_search_paths(work_dir)) {
+    if (existsSync(candidate) === true) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function starter_config_object() {
+  const parsed = JSON.parse(config_template());
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("config template must be a JSON object");
+  }
+  return parsed;
+}
+function write_lich_config(work_dir, config) {
+  ensure_lich_config_dir(work_dir);
+  const file = project_config_path(work_dir);
+  if (existsSync(file) === true) {
+    return already_exists(file);
+  }
+  try {
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+  } catch (error) {
+    if (is_eexist(error) === true) {
+      return already_exists(file);
+    }
+    throw error;
+  }
+  return { path: file, written: true, message: `wrote ${file}` };
+}
+function already_exists(file) {
+  return {
+    path: file,
+    written: false,
+    message: `lich: .lich/config.json already exists at ${file}; not overwriting`
+  };
+}
+function is_eexist(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+
+// src/cli_update.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+var PACKAGE_NAME = "@moikapy/lich";
+var VIEW_ARGS = ["view", PACKAGE_NAME, "version"];
+var INSTALL_ARGS = ["install", "-g", `${PACKAGE_NAME}@latest`];
+var NPM_MISSING = "lich: npm is not on PATH. Install Node.js, or run `npm install -g @moikapy/lich@latest` once npm is available.\n";
+var EXIT_FIRST_HINT = "Exit any running `lich tui` or `lich gateway` first \u2014 npm cannot replace the package while those processes are running.\n";
+function parse_semver(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version.trim());
+  if (match === null || match[1] === void 0 || match[2] === void 0 || match[3] === void 0) {
+    return null;
+  }
+  return [Number(match[1]), Number(match[2]), Number(match[3]), match[4] ?? ""];
+}
+function version_relation(installed, registry) {
+  const left = parse_semver(installed);
+  const right = parse_semver(registry);
+  if (left === null || right === null) {
+    return "invalid";
+  }
+  for (let index = 0; index < 3; index += 1) {
+    const installed_part = left[index];
+    const registry_part = right[index];
+    if (typeof installed_part !== "number" || typeof registry_part !== "number") {
+      return "invalid";
+    }
+    if (installed_part < registry_part) {
+      return "update";
+    }
+    if (installed_part > registry_part) {
+      return "current";
+    }
+  }
+  if (left[3] !== "" && right[3] === "") {
+    return "update";
+  }
+  return "current";
+}
+function detect_install_kind(module_path, env, has_git) {
+  if (env.npm_command === "exec" || module_path.includes(`${path2.sep}_npx${path2.sep}`)) {
+    return "npx";
+  }
+  let dir = path2.dirname(path2.resolve(module_path));
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    if (path2.basename(dir) === "node_modules") {
+      return "npm";
+    }
+    if (has_git(dir) === true) {
+      return "git";
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return "npm";
+}
+function blocked_install_message(kind) {
+  if (kind === "git") {
+    return "lich: this copy is a git clone, not an npm install. Update with `git pull` in the repository.\n";
+  }
+  if (kind === "npx") {
+    return "lich: npx runs a temporary copy and cannot persist an update. Install with `npm install -g @moikapy/lich`.\n";
+  }
+  return null;
+}
+function registry_version(viewed, request) {
+  if (viewed.error_code === "ENOENT") {
+    request.write_stderr(NPM_MISSING);
+    return null;
+  }
+  if (viewed.exit_code !== 0) {
+    const detail = viewed.stderr.trim() || viewed.stdout.trim() || `exit ${viewed.exit_code}`;
+    request.write_stderr(`lich: could not read the registry version of ${PACKAGE_NAME}: ${detail}
+`);
+    return null;
+  }
+  const registry = viewed.stdout.trim();
+  if (parse_semver(registry) === null) {
+    request.write_stderr(`lich: could not read the registry version of ${PACKAGE_NAME}: unexpected version "${registry}"
+`);
+    return null;
+  }
+  return registry;
+}
+function is_permission_failure(installed) {
+  if (installed.error_code === "EACCES" || installed.error_code === "EPERM") {
+    return true;
+  }
+  const text = `${installed.stderr}
+${installed.stdout}`.toLowerCase();
+  return text.includes("eacces") || text.includes("eperm") || text.includes("permission denied");
+}
+function report_install(request, installed) {
+  if (installed.exit_code === 0) {
+    request.write_stdout(`updated ${PACKAGE_NAME}. Run \`lich --version\` in a new shell to confirm.
+`);
+    return 0;
+  }
+  if (installed.error_code === "ENOENT") {
+    request.write_stderr(NPM_MISSING);
+    return 1;
+  }
+  if (is_permission_failure(installed) === true) {
+    request.write_stderr("lich: npm install failed (permission denied). Use a writable npm prefix, or run `npm install -g @moikapy/lich@latest` yourself.\n");
+    return 1;
+  }
+  const detail = installed.stderr.trim() || `exit ${installed.exit_code}`;
+  request.write_stderr(`lich: npm install failed: ${detail}
+`);
+  return 1;
+}
+async function install_if_newer(request, registry) {
+  const relation = version_relation(request.installed_version, registry);
+  if (relation === "invalid") {
+    request.write_stderr(`lich: could not compare versions (installed ${request.installed_version}, registry ${registry})
+`);
+    return 1;
+  }
+  if (relation !== "update") {
+    request.write_stdout(`lich ${request.installed_version} is up to date
+`);
+    return 0;
+  }
+  request.write_stdout(`lich ${request.installed_version} -> ${registry}
+`);
+  request.write_stdout(EXIT_FIRST_HINT);
+  const installed = await request.run_command("npm", INSTALL_ARGS);
+  return report_install(request, installed);
+}
+async function run_lich_update(request) {
+  const blocked = blocked_install_message(request.install_kind);
+  if (blocked !== null) {
+    request.write_stderr(blocked);
+    return 1;
+  }
+  const viewed = await request.run_command("npm", VIEW_ARGS);
+  const registry = registry_version(viewed, request);
+  if (registry === null) {
+    return 1;
+  }
+  return install_if_newer(request, registry);
+}
+function running_under_bun() {
+  return process.versions.bun !== void 0;
+}
+function default_command_runner(command, args) {
+  if (running_under_bun() === true) {
+    return bun_command_runner(command, args);
+  }
+  return node_command_runner(command, args);
+}
+function node_command_runner(command, args) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled === true) {
+        return;
+      }
+      settled = true;
+      resolve(result);
+    };
+    const forward = args[0] === "install";
+    const child = spawn(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (forward === true) {
+        process.stdout.write(text);
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (forward === true) {
+        process.stderr.write(text);
+      }
+    });
+    child.on("error", (error) => {
+      finish({ exit_code: 127, stdout, stderr: error.message, error_code: error.code });
+    });
+    child.on("close", (code) => {
+      finish({ exit_code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+async function read_piped_text(stream, forward, write) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  for (; ; ) {
+    const next = await reader.read();
+    if (next.done === true) {
+      return text;
+    }
+    const chunk = decoder.decode(next.value, { stream: true });
+    text += chunk;
+    if (forward === true) {
+      write(chunk);
+    }
+  }
+}
+function bun_command_runner(command, args) {
+  const forward = args[0] === "install";
+  try {
+    const child = Bun.spawn([command, ...args], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    return Promise.all([
+      read_piped_text(child.stdout, forward, (text) => {
+        process.stdout.write(text);
+      }),
+      read_piped_text(child.stderr, forward, (text) => {
+        process.stderr.write(text);
+      }),
+      child.exited
+    ]).then(([stdout, stderr, exit_code]) => ({ exit_code, stdout, stderr }));
+  } catch (error) {
+    const coded = error;
+    const stderr = typeof coded.message === "string" ? coded.message : "spawn failed";
+    return Promise.resolve({ exit_code: 127, stdout: "", stderr, error_code: coded.code });
+  }
+}
+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"))),
+    run_command: default_command_runner,
+    write_stdout: (text) => {
+      process.stdout.write(text);
+    },
+    write_stderr: (text) => {
+      process.stderr.write(text);
+    }
+  });
+}
+
+// src/setup_wizard.ts
+import { readdirSync } from "fs";
+import path3 from "path";
+var PLATFORMS = ["webhook", "telegram", "discord", "twitch"];
+var PLUGIN_EXT = /\.(mjs|js|ts|mts|cts|jsx|tsx)$/;
+var PROVIDER_DEFAULTS = {
+  ollama: { model: "llama3.2", base_url: "http://localhost:11434" },
+  openai_compat: { model: "gpt-4.1-mini", base_url: "https://api.openai.com/v1", api_key_env: "OPENAI_API_KEY" },
+  anthropic: { model: "claude-sonnet-4", base_url: "https://api.anthropic.com", api_key_env: "ANTHROPIC_API_KEY" }
+};
+function discover_plugin_entries(work_dir) {
+  const dir = path3.resolve(work_dir, ".lich", "plugins");
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const name of names) {
+    if (PLUGIN_EXT.test(name) === true) {
+      entries.push(path3.posix.join(".lich/plugins", name));
+    }
+  }
+  return entries;
+}
+function build_setup_config(answers) {
+  const provider = {
+    kind: answers.provider_kind,
+    name: "main",
+    model: answers.model,
+    base_url: answers.base_url
+  };
+  if (answers.api_key_env !== void 0 && answers.api_key_env.length > 0) {
+    provider["api_key_env"] = answers.api_key_env;
+  }
+  const config = {
+    agent_name: answers.agent_name,
+    providers: [provider],
+    max_turns: 25,
+    plugins: answers.plugins
+  };
+  if (answers.platforms.length > 0) {
+    config["gateway"] = { platforms: answers.platforms, token_envs: answers.token_envs };
+  }
+  return config;
+}
+function blank_as_default(raw, fallback) {
+  const trimmed = raw.trim();
+  return trimmed.length === 0 ? fallback : trimmed;
+}
+function parse_kind(raw) {
+  const trimmed = raw.trim();
+  const kind = trimmed.length === 0 ? "ollama" : trimmed;
+  if (kind === "ollama" || kind === "openai_compat" || kind === "anthropic") {
+    return kind;
+  }
+  return void 0;
+}
+function parse_platforms(raw) {
+  const seen = /* @__PURE__ */ new Set();
+  const platforms = [];
+  for (const part of raw.split(",")) {
+    const name = part.trim().toLowerCase();
+    if (PLATFORMS.includes(name) === false || seen.has(name) === true) {
+      continue;
+    }
+    seen.add(name);
+    platforms.push(name);
+  }
+  return platforms;
+}
+function ask_line(rl, prompt) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled === true) {
+        return;
+      }
+      settled = true;
+      rl.removeListener("SIGINT", on_sigint);
+      rl.removeListener("close", on_close);
+      resolve(value);
+    };
+    const on_sigint = () => finish(void 0);
+    const on_close = () => finish(void 0);
+    rl.once("SIGINT", on_sigint);
+    rl.once("close", on_close);
+    rl.question(prompt, (answer) => finish(answer));
+  });
+}
+async function ask_name(ask) {
+  const raw = await ask("Agent name [lich]: ");
+  if (raw === void 0) {
+    return void 0;
+  }
+  return blank_as_default(raw, "lich");
+}
+async function ask_provider(ask, model_hint2) {
+  const kind_raw = await ask("Provider kind (ollama|openai_compat|anthropic) [ollama]: ");
+  if (kind_raw === void 0) {
+    return void 0;
+  }
+  let kind = parse_kind(kind_raw);
+  if (kind === void 0) {
+    const retry = await ask("Unknown kind. Provider kind (ollama|openai_compat|anthropic) [ollama]: ");
+    if (retry === void 0) {
+      return void 0;
+    }
+    kind = parse_kind(retry) ?? "ollama";
+  }
+  const defaults = PROVIDER_DEFAULTS[kind];
+  const model_default = model_hint2 !== void 0 && model_hint2.length > 0 ? model_hint2 : defaults.model;
+  const model_raw = await ask(`Model [${model_default}]: `);
+  if (model_raw === void 0) {
+    return void 0;
+  }
+  const url_raw = await ask(`Base URL [${defaults.base_url}]: `);
+  if (url_raw === void 0) {
+    return void 0;
+  }
+  const key_default = defaults.api_key_env ?? "";
+  const key_prompt = key_default.length === 0 ? "API key env var name (empty to skip): " : `API key env var name [${key_default}]: `;
+  const key_raw = await ask(key_prompt);
+  if (key_raw === void 0) {
+    return void 0;
+  }
+  const api_key_env = blank_as_default(key_raw, key_default);
+  return {
+    provider_kind: kind,
+    model: blank_as_default(model_raw, model_default),
+    base_url: blank_as_default(url_raw, defaults.base_url),
+    api_key_env: api_key_env.length === 0 ? void 0 : api_key_env
+  };
+}
+function token_env_name(raw, fallback) {
+  const name = blank_as_default(raw, fallback);
+  return is_env_var_name(name) === true ? name : void 0;
+}
+async function ask_token_env(ask, platform, fallback) {
+  const first = await ask(`${platform} token env var [${fallback}] (name only, not the secret): `);
+  if (first === void 0) {
+    return void 0;
+  }
+  const named = token_env_name(first, fallback);
+  if (named !== void 0) {
+    return named;
+  }
+  const retry = await ask(`Env var name must match [A-Za-z_][A-Za-z0-9_]* [${fallback}]: `);
+  if (retry === void 0) {
+    return void 0;
+  }
+  return token_env_name(retry, fallback);
+}
+async function ask_gateway(ask) {
+  const raw = await ask("Gateway platforms (webhook,telegram,discord,twitch; empty to skip): ");
+  if (raw === void 0) {
+    return void 0;
+  }
+  const platforms = parse_platforms(raw);
+  const token_envs = {};
+  for (const platform of platforms) {
+    const name = await ask_token_env(ask, platform, DEFAULT_GATEWAY_TOKEN_ENVS[platform] ?? "");
+    if (name === void 0) {
+      return void 0;
+    }
+    token_envs[platform] = name;
+  }
+  return { platforms, token_envs };
+}
+async function ask_plugins(work_dir, ask) {
+  const found = discover_plugin_entries(work_dir);
+  if (found.length === 0) {
+    return [];
+  }
+  const enabled = [];
+  for (const entry of found) {
+    const answer = await ask(`Enable plugin ${entry}? [y/N]: `);
+    if (answer === void 0) {
+      return void 0;
+    }
+    const yes = answer.trim().toLowerCase();
+    if (yes === "y" || yes === "yes") {
+      enabled.push(entry);
+    }
+  }
+  return enabled;
+}
+async function collect_setup_answers(work_dir, ask, model_hint2) {
+  const agent_name = await ask_name(ask);
+  if (agent_name === void 0) {
+    return void 0;
+  }
+  const provider = await ask_provider(ask, model_hint2);
+  if (provider === void 0) {
+    return void 0;
+  }
+  const gateway = await ask_gateway(ask);
+  if (gateway === void 0) {
+    return void 0;
+  }
+  const plugins = await ask_plugins(work_dir, ask);
+  if (plugins === void 0) {
+    return void 0;
+  }
+  return { agent_name, ...provider, platforms: gateway.platforms, token_envs: gateway.token_envs, plugins };
+}
 
 // src/cli.ts
 var FLAG_KEYS = {
@@ -94,11 +594,14 @@ function usage_text() {
     "lich \u2014 a TypeScript AI agent harness",
     "",
     "Usage:",
+    "  lich                   open the TUI (first run: setup wizard, then TUI)",
+    "  lich init              write .lich/config.json without the wizard (flags apply; never overwrites)",
     '  lich "one shot task"   run a single task and print the reply',
     "  lich chat              interactive chat (commands: /exit, /quit)",
     "  lich tui               interactive terminal UI (ink)",
     "  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 --help            show this help",
     "  lich --version         print version",
     "",
@@ -239,8 +742,15 @@ function apply_overrides(config, overrides) {
   }
   apply_provider_override(config, overrides);
 }
+function load_discovered_config(work_dir) {
+  const found = existing_config_path(work_dir);
+  if (found === void 0) {
+    return void 0;
+  }
+  return load_config(found);
+}
 function build_config(options) {
-  const base = options.config_path === void 0 ? load_config() ?? { providers: [env_provider(options.overrides)] } : load_config_file(options.config_path);
+  const base = options.config_path === void 0 ? load_discovered_config(work_dir_of(options)) ?? { providers: [env_provider(options.overrides)] } : load_config_file(options.config_path);
   apply_overrides(base, options.overrides);
   const providers = base["providers"];
   if (Array.isArray(providers) === false || providers.length === 0) {
@@ -274,7 +784,7 @@ function attach_progress(emitter) {
   });
 }
 async function run_one_shot(config, input) {
-  const agent = create_agent(config);
+  const agent = await create_agent_with_plugins(config);
   const stop_progress = attach_progress(agent.events);
   let result;
   try {
@@ -316,7 +826,7 @@ async function run_chat_turn(agent, input) {
     stop_progress();
   }
 }
-function ask_line(rl) {
+function ask_line2(rl) {
   return new Promise((resolve) => {
     const on_close = () => resolve("");
     rl.question("> ", (answer) => {
@@ -327,11 +837,11 @@ function ask_line(rl) {
   });
 }
 async function run_chat(config) {
-  const agent = create_agent(config);
+  const agent = await create_agent_with_plugins(config);
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
     for (; ; ) {
-      const line = await ask_line(rl);
+      const line = await ask_line2(rl);
       if (line.trim() === "") {
         return 0;
       }
@@ -345,22 +855,136 @@ async function run_chat(config) {
     rl.close();
   }
 }
+function model_hint(options) {
+  const model = options.overrides["provider_model"] ?? process.env.LICH_MODEL;
+  if (model === void 0 || model.length === 0) {
+    return void 0;
+  }
+  return model;
+}
+function skip_setup_message(existing) {
+  if (existing.endsWith(`${path4.sep}.lich${path4.sep}config.json`) === true) {
+    return `lich: .lich/config.json already exists at ${existing}; skipping setup`;
+  }
+  return `lich: config already exists at ${existing}; skipping setup`;
+}
+function work_dir_of(options) {
+  return options.overrides["work_dir"] ?? process.cwd();
+}
+async function offer_wizard(work_dir, hint) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answers = await collect_setup_answers(work_dir, (prompt) => ask_line(rl, prompt), hint);
+    if (answers === void 0) {
+      return "cancelled";
+    }
+    const result = write_lich_config(work_dir, build_setup_config(answers));
+    process.stdout.write(`${result.message}
+`);
+    return result.path;
+  } finally {
+    rl.close();
+  }
+}
+async function maybe_first_run(options, work_dir) {
+  if (options.config_path !== void 0) {
+    return void 0;
+  }
+  const existing = existing_config_path(work_dir);
+  if (existing !== void 0) {
+    process.stdout.write(`${skip_setup_message(existing)}
+`);
+    options.config_path = existing;
+    return void 0;
+  }
+  const wrote = await offer_wizard(work_dir, model_hint(options));
+  if (wrote === "cancelled") {
+    process.stderr.write("lich: setup cancelled; nothing written\n");
+    return 1;
+  }
+  options.config_path = wrote;
+  return void 0;
+}
+async function run_bare(options) {
+  if (process.stdin.isTTY !== true) {
+    process.stderr.write("lich: stdin is not a TTY; skipping setup wizard. Run `lich init` to write .lich/config.json, or `lich --help` for usage.\n");
+    return 1;
+  }
+  const work_dir = work_dir_of(options);
+  const stopped = await maybe_first_run(options, work_dir);
+  if (stopped !== void 0) {
+    return stopped;
+  }
+  return run_tui_entry(build_config_for(options, "tui"));
+}
+function model_still_placeholder(config) {
+  const providers = config["providers"];
+  const first = Array.isArray(providers) === true ? providers[0] : void 0;
+  if (typeof first !== "object" || first === null) {
+    return false;
+  }
+  return first["model"] === "<model-name>";
+}
+function run_init(options) {
+  if (options.positionals.length > 1) {
+    throw new Error("init takes no extra arguments");
+  }
+  const config = starter_config_object();
+  apply_overrides(config, options.overrides);
+  const result = write_lich_config(work_dir_of(options), config);
+  process.stdout.write(`${result.message}
+`);
+  if (result.written === true && model_still_placeholder(config) === true) {
+    process.stdout.write("next: edit the model in .lich/config.json if needed, then run `lich`\n");
+  }
+  return 0;
+}
 async function run_tui_entry(config) {
-  const { run_tui } = await import("./tui-VYBJSGRV.js");
+  const { run_tui } = await import("./tui-2VO6LAFM.js");
   return run_tui(config);
 }
+function gateway_platforms(config, cli_platforms) {
+  if (cli_platforms.length > 0) {
+    return cli_platforms;
+  }
+  const configured = config.gateway?.platforms ?? [];
+  return configured.length === 0 ? ["webhook"] : configured;
+}
 async function run_gateway_entry(config, platforms) {
-  const { run_gateway } = await import("./gateway-XTYDYT67.js");
-  return run_gateway(config, platforms.length === 0 ? ["webhook"] : platforms);
+  const { run_gateway } = await import("./gateway-W6S43ETE.js");
+  return run_gateway(config, gateway_platforms(config, platforms));
+}
+function is_cli_entry(input) {
+  if (input.bun === true) {
+    return input.import_meta_main === true;
+  }
+  return node_entry_matches(input.module_url, input.argv1);
 }
 function is_main_module() {
-  const entry = process.argv[1];
-  if (entry === void 0) {
+  return is_cli_entry({
+    bun: process.versions.bun !== void 0,
+    import_meta_main: import.meta.main,
+    module_url: import.meta.url,
+    argv1: process.argv[1]
+  });
+}
+function node_entry_matches(module_url, entry) {
+  if (entry === void 0 || entry === "") {
+    return false;
+  }
+  const resolved = path4.resolve(entry);
+  if (module_url === pathToFileURL(resolved).href) {
+    return true;
+  }
+  return same_real_file(fileURLToPath(module_url), resolved);
+}
+function same_real_file(left, right) {
+  if (existsSync3(left) === false || existsSync3(right) === false) {
     return false;
   }
-  return import.meta.url === pathToFileURL(path2.resolve(entry)).href;
+  return realpathSync(left) === realpathSync(right);
 }
-async function main(argv) {
+async function run_cli(argv) {
   const options = parse_args(argv);
   if (options.help === true) {
     process.stdout.write(`${usage_text()}
@@ -374,15 +998,22 @@ async function main(argv) {
   }
   const [first] = options.positionals;
   if (first === void 0) {
-    process.stderr.write(`${usage_text()}
-`);
-    return 1;
+    return run_bare(options);
+  }
+  if (first === "init") {
+    return run_init(options);
   }
   if (first === "config") {
     process.stdout.write(`${config_template()}
 `);
     return 0;
   }
+  if (first === "update") {
+    if (options.positionals.length > 1) {
+      throw new Error("update takes no arguments");
+    }
+    return run_update(fileURLToPath(import.meta.url));
+  }
   if (first === "chat") {
     if (options.positionals.length > 1) {
       throw new Error("chat mode takes no task argument");
@@ -398,7 +1029,7 @@ async function main(argv) {
   return run_one_shot(build_config_for(options, "one-shot"), options.positionals.join(" "));
 }
 if (is_main_module() === true) {
-  main(process.argv.slice(2)).then((code) => {
+  run_cli(process.argv.slice(2)).then((code) => {
     process.exitCode = code;
   }).catch((error) => {
     process.stderr.write(`lich: ${error_message(error)}
@@ -407,4 +1038,10 @@ if (is_main_module() === true) {
     process.exitCode = 1;
   });
 }
+export {
+  is_cli_entry,
+  run_chat,
+  run_cli,
+  run_one_shot
+};
 //# sourceMappingURL=cli.js.map