aemeathcli 1.0.0

package/dist/cli.js

@@ -0,0 +1,703 @@
+#!/usr/bin/env node
+import './chunk-CGEV3ARR.js';
+import './chunk-CYQNBB25.js';
+import { initializeDirectories } from './chunk-NBR3GHMT.js';
+import './chunk-CS5X3BWX.js';
+import './chunk-HCIHOHLX.js';
+import './chunk-ZGOHARPV.js';
+import { logger } from './chunk-JAXXTYID.js';
+import { Command } from 'commander';
+import pc2 from 'picocolors';
+import { randomUUID } from 'crypto';
+
+function createChatCommand() {
+  const chat = new Command("chat").description("Start interactive chat mode (default)").argument("[message...]", "Initial message to send").option("-m, --model <model>", "Override model for this session").option("-r, --role <role>", "Set the task role (planning, coding, review, testing, bugfix)").option("--system <prompt>", "Custom system prompt").option("--no-stream", "Disable streaming output").action(async (messageParts, options) => {
+    const message = messageParts.join(" ");
+    const { startChatSession } = await import('./App-P4MYD4QY.js');
+    const model = options["model"];
+    const role = options["role"];
+    const systemPrompt = options["system"];
+    const initialMessage = message || void 0;
+    await startChatSession({
+      ...initialMessage !== void 0 ? { initialMessage } : {},
+      ...model !== void 0 ? { model } : {},
+      ...role !== void 0 ? { role } : {},
+      ...systemPrompt !== void 0 ? { systemPrompt } : {},
+      streaming: options["stream"] !== false
+    });
+  });
+  return chat;
+}
+function createPlanCommand() {
+  const plan = new Command("plan").description("Enter planning mode with a high-reasoning model").argument("[message...]", "Planning prompt").option("-m, --model <model>", "Override model (default: planning role)").action(async (messageParts, options) => {
+    const message = messageParts.join(" ");
+    const { startChatSession } = await import('./App-P4MYD4QY.js');
+    const model = options["model"];
+    const initialMessage = message || void 0;
+    await startChatSession({
+      ...initialMessage !== void 0 ? { initialMessage } : {},
+      ...model !== void 0 ? { model } : {},
+      role: "planning",
+      streaming: true
+    });
+  });
+  return plan;
+}
+function createReviewCommand() {
+  const review = new Command("review").description("Code review mode with a thorough model").argument("[files...]", "Files to review").option("-m, --model <model>", "Override model (default: review role)").action(async (files, options) => {
+    const message = files.length > 0 ? `Review these files: ${files.join(", ")}` : "Review the recent changes";
+    const { startChatSession } = await import('./App-P4MYD4QY.js');
+    const model = options["model"];
+    await startChatSession({
+      initialMessage: message,
+      ...model !== void 0 ? { model } : {},
+      role: "review",
+      streaming: true
+    });
+  });
+  return review;
+}
+function createTestCommand() {
+  const test = new Command("test").description("Testing mode with a cost-efficient model").argument("[message...]", "Testing prompt").option("-m, --model <model>", "Override model (default: testing role)").action(async (messageParts, options) => {
+    const message = messageParts.join(" ");
+    const { startChatSession } = await import('./App-P4MYD4QY.js');
+    const model = options["model"];
+    await startChatSession({
+      initialMessage: message || "Generate tests for the recent changes",
+      ...model !== void 0 ? { model } : {},
+      role: "testing",
+      streaming: true
+    });
+  });
+  return test;
+}
+function createConfigCommand() {
+  const config = new Command("config").description("Configuration management");
+  config.command("get [key]").description("Get configuration value (or all if no key)").action(async (key) => {
+    try {
+      const { ConfigStore } = await import('./config-store-W6FBCQAQ.js');
+      const store = new ConfigStore();
+      const cfg = await store.loadGlobal();
+      if (key) {
+        const value = getNestedValue(cfg, key);
+        if (value === void 0) {
+          process.stderr.write(pc2.red(`Configuration key not found: ${key}
+`));
+          process.exitCode = 1;
+          return;
+        }
+        process.stdout.write(`${key} = ${JSON.stringify(value, null, 2)}
+`);
+      } else {
+        process.stdout.write(JSON.stringify(cfg, null, 2) + "\n");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Failed to read config: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  config.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+    try {
+      const { ConfigStore } = await import('./config-store-W6FBCQAQ.js');
+      const store = new ConfigStore();
+      const cfg = await store.loadGlobal();
+      let parsedValue;
+      try {
+        parsedValue = JSON.parse(value);
+      } catch {
+        parsedValue = value;
+      }
+      setNestedValue(cfg, key, parsedValue);
+      await store.saveGlobal(cfg);
+      process.stdout.write(pc2.green(`Set ${key} = ${JSON.stringify(parsedValue)}
+`));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Failed to set config: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  config.command("init").description("Initialize configuration with interactive setup").action(async () => {
+    try {
+      const { runFirstRunSetup } = await import('./App-P4MYD4QY.js');
+      await runFirstRunSetup();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Setup failed: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  return config;
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!key) continue;
+    if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  if (lastKey) {
+    current[lastKey] = value;
+  }
+}
+var VALID_PROVIDERS = ["claude", "codex", "gemini", "kimi"];
+function isValidProvider(value) {
+  return VALID_PROVIDERS.includes(value);
+}
+var PROVIDER_MODEL_SWITCH = {
+  claude: { provider: "anthropic", model: "claude-sonnet-4-6" },
+  codex: { provider: "openai", model: "gpt-5.2" },
+  gemini: { provider: "google", model: "gemini-2.5-pro" },
+  kimi: { provider: "kimi", model: "kimi-for-coding" }
+};
+function createAuthCommand() {
+  const auth = new Command("auth").description("Authentication & account management");
+  auth.command("login <provider>").description("Log in to a provider (claude, codex, gemini, kimi)").action(async (provider) => {
+    if (!isValidProvider(provider)) {
+      process.stderr.write(
+        pc2.red(`Unknown provider: "${provider}". Valid: ${VALID_PROVIDERS.join(", ")}
+`)
+      );
+      process.exitCode = 2;
+      return;
+    }
+    process.stdout.write(pc2.cyan(`Logging in to ${provider}...
+`));
+    try {
+      const loginModule = await loadLoginModule(provider);
+      await loginModule.login();
+      process.stdout.write(pc2.green(`Successfully logged in to ${provider}
+`));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Login failed: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  auth.command("logout [provider]").description("Log out of a provider (or all with --all)").option("--all", "Log out of all providers").action(async (provider, options) => {
+    if (options.all) {
+      for (const p of VALID_PROVIDERS) {
+        try {
+          const loginModule = await loadLoginModule(p);
+          await loginModule.logout();
+          process.stdout.write(pc2.green(`Logged out of ${p}
+`));
+        } catch {
+        }
+      }
+      return;
+    }
+    if (!provider || !isValidProvider(provider)) {
+      process.stderr.write(
+        pc2.red(`Specify a provider or use --all. Valid: ${VALID_PROVIDERS.join(", ")}
+`)
+      );
+      process.exitCode = 2;
+      return;
+    }
+    try {
+      const loginModule = await loadLoginModule(provider);
+      await loginModule.logout();
+      process.stdout.write(pc2.green(`Logged out of ${provider}
+`));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Logout failed: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  auth.command("status").description("Show login status for all providers").action(async () => {
+    for (const provider of VALID_PROVIDERS) {
+      try {
+        const loginModule = await loadLoginModule(provider);
+        const status = await loginModule.getStatus();
+        if (status.loggedIn) {
+          process.stdout.write(
+            pc2.green(`  \u2713 ${provider}`) + ` \u2014 Logged in as ${status.email ?? "unknown"} (${status.plan ?? "unknown plan"})
+`
+          );
+        } else {
+          process.stdout.write(pc2.red(`  \u2717 ${provider}`) + " \u2014 Not logged in\n");
+        }
+      } catch {
+        process.stdout.write(pc2.red(`  \u2717 ${provider}`) + " \u2014 Not configured\n");
+      }
+    }
+    try {
+      const { ApiKeyFallback } = await import('./api-key-fallback-YQQBOQIL.js');
+      const fallback = new ApiKeyFallback();
+      const apiKeyStatus = [
+        { label: "Claude", provider: "anthropic" },
+        { label: "OpenAI", provider: "openai" },
+        { label: "Google", provider: "google" },
+        { label: "Kimi", provider: "kimi" }
+      ];
+      process.stdout.write("\nFallback API keys:\n");
+      for (const item of apiKeyStatus) {
+        const hasKey = await fallback.hasKey(item.provider);
+        process.stdout.write(`  ${item.label}: ${hasKey ? "set" : "not set"}
+`);
+      }
+    } catch {
+    }
+  });
+  auth.command("set-key <provider> <key>").description("Set an API key for a provider (fallback for CI/headless)").action(async (provider, key) => {
+    if (!isValidProvider(provider) && provider !== "openai" && provider !== "google") {
+      process.stderr.write(pc2.red(`Unknown provider: "${provider}"
+`));
+      process.exitCode = 2;
+      return;
+    }
+    try {
+      const { ApiKeyFallback } = await import('./api-key-fallback-YQQBOQIL.js');
+      const fallback = new ApiKeyFallback();
+      const providerMap = {
+        claude: "anthropic",
+        openai: "openai",
+        codex: "openai",
+        gemini: "google",
+        google: "google",
+        kimi: "kimi"
+      };
+      const mappedProvider = providerMap[provider];
+      if (mappedProvider) {
+        await fallback.setKey(mappedProvider, key);
+        process.stdout.write(pc2.green(`API key set for ${provider}
+`));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Failed to set key: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  auth.command("switch <provider>").description("Set a provider as the default").action(async (provider) => {
+    if (!isValidProvider(provider)) {
+      process.stderr.write(
+        pc2.red(`Unknown provider: "${provider}". Valid: ${VALID_PROVIDERS.join(", ")}
+`)
+      );
+      process.exitCode = 2;
+      return;
+    }
+    try {
+      const target = PROVIDER_MODEL_SWITCH[provider];
+      const { ConfigStore } = await import('./config-store-W6FBCQAQ.js');
+      const store = new ConfigStore();
+      const cfg = store.loadGlobal();
+      const nextConfig = {
+        ...cfg,
+        defaultModel: target.model,
+        providers: {
+          ...cfg.providers,
+          [target.provider]: {
+            ...cfg.providers[target.provider] ?? {},
+            enabled: true
+          }
+        }
+      };
+      store.saveGlobal(nextConfig);
+      process.stdout.write(
+        pc2.green(`Default provider switched to ${provider} (model: ${target.model})
+`)
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(pc2.red(`Failed to switch provider: ${message}
+`));
+      process.exitCode = 3;
+    }
+  });
+  return auth;
+}
+async function loadLoginModule(provider) {
+  switch (provider) {
+    case "claude": {
+      const mod = await import('./claude-login-5WELXPKT.js');
+      return new mod.ClaudeLogin();
+    }
+    case "codex": {
+      const mod = await import('./codex-login-7HHLJHBF.js');
+      return new mod.CodexLogin();
+    }
+    case "gemini": {
+      const mod = await import('./gemini-login-ZZLYC3J6.js');
+      return new mod.GeminiLogin();
+    }
+    case "kimi": {
+      const mod = await import('./kimi-login-CZPS63NK.js');
+      return new mod.KimiLogin();
+    }
+  }
+}
+
+// src/cli/cli.ts
+var VERSION = "1.0.0";
+function getFlagValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    return void 0;
+  }
+  const value = args[index + 1];
+  return value && !value.startsWith("-") ? value : void 0;
+}
+function isIPCMessage(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return record["jsonrpc"] === "2.0" && typeof record["method"] === "string";
+}
+function sendAgentIPC(method, params) {
+  if (typeof process.send === "function") {
+    const message = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    process.send(message);
+  }
+}
+async function maybeRunAgentMode(args) {
+  if (!args.includes("--agent") && process.env["AEMEATHCLI_AGENT_MODE"] !== "1") {
+    return false;
+  }
+  const teamName = getFlagValue(args, "--team") ?? process.env["AEMEATHCLI_TEAM_NAME"] ?? "unknown-team";
+  const agentName = getFlagValue(args, "--name") ?? process.env["AEMEATHCLI_AGENT_NAME"] ?? "agent";
+  const model = getFlagValue(args, "--model") ?? "claude-sonnet-4-6";
+  const role = getFlagValue(args, "--role") ?? "coding";
+  const agentId = process.env["AEMEATHCLI_AGENT_ID"] ?? randomUUID();
+  let registryPromise;
+  function getRegistry() {
+    if (!registryPromise) {
+      registryPromise = import('./registry-4KD24ZC3.js').then(
+        ({ createDefaultRegistry }) => createDefaultRegistry()
+      );
+    }
+    return registryPromise;
+  }
+  let toolRegistryPromise;
+  function getToolRegistry() {
+    if (!toolRegistryPromise) {
+      toolRegistryPromise = import('./tools-TSMXMHIF.js').then(
+        ({ createDefaultRegistry: createToolReg }) => createToolReg({
+          projectRoot: process.cwd(),
+          workingDirectory: process.cwd(),
+          permissionMode: "permissive",
+          allowedPaths: [process.cwd()],
+          blockedCommands: []
+        })
+      );
+    }
+    return toolRegistryPromise;
+  }
+  function formatToolActivity(name, args2) {
+    switch (name) {
+      case "read":
+      case "write":
+      case "edit":
+        return typeof args2["file_path"] === "string" ? args2["file_path"] : "";
+      case "glob":
+        return typeof args2["pattern"] === "string" ? args2["pattern"] : "";
+      case "grep": {
+        const pat = typeof args2["pattern"] === "string" ? args2["pattern"] : "";
+        const dir = typeof args2["path"] === "string" ? ` in ${args2["path"]}` : "";
+        return `"${pat}"${dir}`;
+      }
+      case "bash": {
+        const cmd = typeof args2["command"] === "string" ? args2["command"] : "";
+        return cmd.length > 60 ? cmd.slice(0, 60) + "..." : cmd;
+      }
+      default:
+        return JSON.stringify(args2).slice(0, 60);
+    }
+  }
+  function formatResultSummary(name, content, isError) {
+    if (isError) return `Error: ${content.slice(0, 100)}`;
+    const lines = content.split("\n").length;
+    switch (name) {
+      case "read":
+        return `${lines} lines`;
+      case "glob":
+        return content === "No files found" ? "no files" : `${lines} files`;
+      case "grep":
+        return content === "No matches found." ? "no matches" : `${lines} lines`;
+      case "write":
+      case "edit":
+        return content.length > 80 ? content.slice(0, 80) : content;
+      default:
+        return content.length > 80 ? content.slice(0, 80) + "..." : content;
+    }
+  }
+  const MAX_TOOL_ITERATIONS = 10;
+  const MAX_TOOL_RESULT_LENGTH = 1e4;
+  async function processTask(taskId, prompt) {
+    sendAgentIPC("agent.taskUpdate", { agentId, taskId, status: "in_progress" });
+    sendAgentIPC("agent.streamChunk", {
+      agentId,
+      taskId,
+      model,
+      content: `Initializing provider for ${model}...
+`
+    });
+    try {
+      const registry = await getRegistry();
+      if (!registry.hasModel(model)) {
+        sendAgentIPC("agent.streamChunk", {
+          agentId,
+          taskId,
+          model,
+          content: `
+Error: No provider available for model "${model}". Check authentication with 'aemeathcli auth login'.
+`
+        });
+        sendAgentIPC("agent.taskUpdate", { agentId, taskId, status: "completed" });
+        return;
+      }
+      const provider = registry.getForModel(model);
+      sendAgentIPC("agent.streamChunk", {
+        agentId,
+        taskId,
+        model,
+        content: `Provider ready (${provider.name}). Loading tools...
+`
+      });
+      const toolRegistry = await getToolRegistry();
+      const toolDefs = toolRegistry.getDefinitions();
+      sendAgentIPC("agent.streamChunk", {
+        agentId,
+        taskId,
+        model,
+        content: `${toolDefs.length} tools loaded. Sending request to ${model}...
+`
+      });
+      const toolContext = {
+        projectRoot: process.cwd(),
+        workingDirectory: process.cwd(),
+        permissionMode: "permissive",
+        allowedPaths: [process.cwd()],
+        blockedCommands: []
+      };
+      const systemPrompt = `You are ${agentName}, an AI agent in team "${teamName}" with the role of ${role}. You have access to tools for reading files, writing files, editing code, searching, and executing shell commands. Use these tools to complete the assigned task thoroughly. Focus only on your specific role.`;
+      const messages = [{
+        id: randomUUID(),
+        role: "user",
+        content: prompt,
+        createdAt: /* @__PURE__ */ new Date()
+      }];
+      for (let iteration = 0; iteration < MAX_TOOL_ITERATIONS; iteration++) {
+        let collectedText = "";
+        const collectedToolCalls = [];
+        const stream = provider.stream({
+          model,
+          messages,
+          system: systemPrompt,
+          maxTokens: 8e3,
+          ...toolDefs.length > 0 ? { tools: toolDefs } : {}
+        });
+        for await (const chunk of stream) {
+          if (chunk.type === "text" && chunk.content) {
+            collectedText += chunk.content;
+            sendAgentIPC("agent.streamChunk", {
+              agentId,
+              taskId,
+              model,
+              content: chunk.content
+            });
+          } else if (chunk.type === "tool_call" && chunk.toolCall) {
+            collectedToolCalls.push(chunk.toolCall);
+            const tc = chunk.toolCall;
+            const summary = formatToolActivity(tc.name, tc.arguments);
+            sendAgentIPC("agent.streamChunk", {
+              agentId,
+              taskId,
+              model,
+              content: `
+\u2699 ${tc.name} ${summary}
+`
+            });
+          } else if (chunk.type === "error" && chunk.error) {
+            const errorMsg = chunk.error.length > 300 ? chunk.error.slice(0, 300) + "..." : chunk.error;
+            sendAgentIPC("agent.streamChunk", {
+              agentId,
+              taskId,
+              model,
+              content: `
+Stream error: ${errorMsg}
+`
+            });
+          }
+        }
+        if (collectedToolCalls.length === 0) {
+          break;
+        }
+        messages.push({
+          id: randomUUID(),
+          role: "assistant",
+          content: collectedText,
+          toolCalls: collectedToolCalls,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+        for (const tc of collectedToolCalls) {
+          const result = await toolRegistry.execute(tc, toolContext);
+          const briefResult = formatResultSummary(tc.name, result.content, result.isError);
+          sendAgentIPC("agent.streamChunk", {
+            agentId,
+            taskId,
+            model,
+            content: `  \u2192 ${briefResult}
+`
+          });
+          const truncatedContent = result.content.length > MAX_TOOL_RESULT_LENGTH ? result.content.slice(0, MAX_TOOL_RESULT_LENGTH) + "\n...(truncated)" : result.content;
+          messages.push({
+            id: randomUUID(),
+            role: "tool",
+            content: truncatedContent,
+            toolCalls: [{ id: tc.id, name: tc.name, arguments: {} }],
+            createdAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+    } catch (error) {
+      const rawMsg = error instanceof Error ? error.message : String(error);
+      const msg = rawMsg.length > 300 ? rawMsg.slice(0, 300) + "..." : rawMsg;
+      sendAgentIPC("agent.streamChunk", {
+        agentId,
+        taskId,
+        model,
+        content: `
+Error: ${msg}
+`
+      });
+    }
+    sendAgentIPC("agent.taskUpdate", { agentId, taskId, status: "completed" });
+  }
+  sendAgentIPC("agent.register", {
+    agentId,
+    agentName,
+    teamName,
+    model,
+    role
+  });
+  const keepAlive = setInterval(() => {
+  }, 6e4);
+  const shutdown = () => {
+    clearInterval(keepAlive);
+    process.exit(0);
+  };
+  process.on("message", (raw) => {
+    if (!isIPCMessage(raw)) {
+      return;
+    }
+    if (raw.method === "hub.taskAssign") {
+      const taskId = typeof raw.params["taskId"] === "string" ? raw.params["taskId"] : randomUUID();
+      const subject = typeof raw.params["subject"] === "string" ? raw.params["subject"] : "";
+      const description = typeof raw.params["description"] === "string" ? raw.params["description"] : "";
+      void processTask(taskId, description || subject || "Describe what you can help with.");
+      return;
+    }
+    if (raw.method === "hub.shutdown") {
+      shutdown();
+    }
+  });
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+  return true;
+}
+async function main() {
+  if (await maybeRunAgentMode(process.argv.slice(2))) {
+    return;
+  }
+  initializeDirectories();
+  const program = new Command().name("aemeathcli").description(
+    "Next-generation multi-model CLI coding tool with agent teams and split-panel coordination"
+  ).version(VERSION, "-v, --version").option("-m, --model <model>", "Override model for this session").option("-r, --role <role>", "Set the task role").option("--verbose", "Enable verbose output").option("--no-color", "Disable colored output").option("--permission-mode <mode>", "Permission mode (strict, standard, permissive)").option("--project-root <path>", "Override project root detection");
+  program.addCommand(createChatCommand());
+  program.addCommand(createPlanCommand());
+  program.addCommand(createReviewCommand());
+  program.addCommand(createTestCommand());
+  program.addCommand(createConfigCommand());
+  program.addCommand(createAuthCommand());
+  program.action(async (options, command) => {
+    const args = command.args;
+    let message = args.length > 0 ? args.join(" ") : void 0;
+    let isAgentPane = false;
+    if (message === void 0) {
+      const promptFilePath = process.env["AEMEATHCLI_PROMPT_FILE"];
+      if (promptFilePath !== void 0 && promptFilePath.length > 0) {
+        try {
+          const { readFileSync } = await import('fs');
+          message = readFileSync(promptFilePath, "utf-8").trim();
+          isAgentPane = true;
+        } catch {
+        }
+      }
+    }
+    const { startChatSession } = await import('./App-P4MYD4QY.js');
+    const model = options["model"];
+    const role = options["role"];
+    await startChatSession({
+      ...message !== void 0 ? { initialMessage: message } : {},
+      ...model !== void 0 ? { model } : {},
+      ...role !== void 0 ? { role } : {},
+      ...isAgentPane ? { isAgentPane: true } : {},
+      streaming: true
+    });
+  });
+  checkForUpdates();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error({ error: error.message }, "CLI error");
+      process.stderr.write(pc2.red(`Error: ${error.message}
+`));
+    }
+    process.exitCode = 1;
+  }
+}
+function checkForUpdates() {
+  import('update-notifier').then(({ default: updateNotifier }) => {
+    const notifier = updateNotifier({
+      pkg: { name: "aemeathcli", version: VERSION },
+      updateCheckInterval: 1e3 * 60 * 60 * 24
+      // 24 hours
+    });
+    notifier.notify({ isGlobal: true });
+  }).catch(() => {
+  });
+}
+main().catch((error) => {
+  process.stderr.write(
+    pc2.red(`Fatal error: ${error instanceof Error ? error.message : String(error)}
+`)
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map