awarts 0.2.3 → 0.2.5

package/dist/index.js

@@ -5774,6 +5774,89 @@ function divider() {
   console.log(`  ${source_default.dim("─".repeat(50))}`);
 }
 
+// src/lib/daemon.ts
+import fs8 from "node:fs/promises";
+import { openSync } from "node:fs";
+import path4 from "node:path";
+import os5 from "node:os";
+import { spawn } from "node:child_process";
+var AWARTS_DIR2 = path4.join(os5.homedir(), ".awarts");
+var PID_FILE = path4.join(AWARTS_DIR2, "daemon.pid");
+var LOG_FILE = path4.join(AWARTS_DIR2, "daemon.log");
+var DEFAULT_INTERVAL_MS = 5 * 60 * 1000;
+async function ensureDir2() {
+  await fs8.mkdir(AWARTS_DIR2, { recursive: true });
+}
+async function readPid() {
+  try {
+    const raw = await fs8.readFile(PID_FILE, "utf-8");
+    const pid = parseInt(raw.trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+async function writePid(pid) {
+  await ensureDir2();
+  await fs8.writeFile(PID_FILE, String(pid), "utf-8");
+}
+async function removePid() {
+  try {
+    await fs8.unlink(PID_FILE);
+  } catch {}
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function appendLog(message) {
+  await ensureDir2();
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${message}
+`;
+  await fs8.appendFile(LOG_FILE, line, "utf-8");
+}
+async function readLogTail(lines = 50) {
+  try {
+    const content = await fs8.readFile(LOG_FILE, "utf-8");
+    const allLines = content.split(`
+`).filter(Boolean);
+    return allLines.slice(-lines).join(`
+`);
+  } catch {
+    return "(no log file found)";
+  }
+}
+async function spawnDaemon(intervalMs) {
+  await ensureDir2();
+  const cliScript = process.argv[1];
+  const logFd = openSync(LOG_FILE, "a");
+  const child = spawn(process.execPath, [cliScript, "daemon", "__run", "--interval", String(intervalMs)], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  const pid = child.pid;
+  if (!pid) {
+    throw new Error("Failed to spawn daemon process");
+  }
+  await writePid(pid);
+  return pid;
+}
+
 // src/commands/login.ts
 var POLL_INTERVAL_MS = 2000;
 var MAX_POLLS = 300;
@@ -5855,7 +5938,20 @@ async function startDeviceAuth() {
         kv("User ID", user_id);
         success("Token saved to ~/.awarts/auth.json");
         console.log();
-        dim("You can now run  awarts push  or  awarts sync");
+        try {
+          const existingPid = await readPid();
+          const isRunning = existingPid ? isProcessRunning(existingPid) : false;
+          if (!isRunning) {
+            const pid = await spawnDaemon(DEFAULT_INTERVAL_MS);
+            success(`Auto-sync daemon started (PID ${pid}, every 5 min)`);
+            dim("Your usage data will sync automatically in the background.");
+            dim("Manage with:  awarts daemon status | stop | logs");
+          } else {
+            dim("Auto-sync daemon is already running.");
+          }
+        } catch {
+          dim("Run  awarts daemon start  to enable auto-sync.");
+        }
         console.log();
         return;
       }
@@ -5875,17 +5971,25 @@ function sleep(ms) {
 }
 
 // src/adapters/claude.ts
-import fs8 from "node:fs/promises";
-import path4 from "node:path";
-import os5 from "node:os";
-var CLAUDE_DIR = path4.join(os5.homedir(), ".claude");
-var STATS_CACHE = path4.join(CLAUDE_DIR, "stats-cache.json");
+import fs9 from "node:fs/promises";
+import path5 from "node:path";
+import os6 from "node:os";
+var CLAUDE_DIR = path5.join(os6.homedir(), ".claude");
+var STATS_CACHE = path5.join(CLAUDE_DIR, "stats-cache.json");
 var MODEL_PRICING = {
-  "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.875, cacheWrite: 18.75 },
-  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.875, cacheWrite: 18.75 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-1": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-3": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
   "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-3-7": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
   "claude-sonnet-3-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-haiku-3-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 }
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-haiku-3-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "claude-haiku-3": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 }
 };
 var DEFAULT_PRICING = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
 function getPricing(model) {
@@ -5903,7 +6007,7 @@ function estimateCost(model, inputTokens, outputTokens, cacheReadTokens, cacheCr
 }
 async function fileExists(filePath) {
   try {
-    const stat = await fs8.stat(filePath);
+    const stat = await fs9.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -5911,14 +6015,14 @@ async function fileExists(filePath) {
 }
 async function dirExists(dir) {
   try {
-    const stat = await fs8.stat(dir);
+    const stat = await fs9.stat(dir);
     return stat.isDirectory();
   } catch {
     return false;
   }
 }
 async function readStatsCache() {
-  const raw = await fs8.readFile(STATS_CACHE, "utf-8");
+  const raw = await fs9.readFile(STATS_CACHE, "utf-8");
   const cache = JSON.parse(raw);
   const dailyTokens = cache.dailyModelTokens;
   if (!dailyTokens || dailyTokens.length === 0)
@@ -5928,6 +6032,7 @@ async function readStatsCache() {
   let totalCacheRead = 0;
   let totalCacheCreation = 0;
   let totalCost = 0;
+  let hasRealCost = false;
   if (cache.modelUsage) {
     for (const [model, usage] of Object.entries(cache.modelUsage)) {
       totalInputTokens += usage.inputTokens || 0;
@@ -5936,6 +6041,7 @@ async function readStatsCache() {
       totalCacheCreation += usage.cacheCreationInputTokens || 0;
       if (usage.costUSD > 0) {
         totalCost += usage.costUSD;
+        hasRealCost = true;
       } else {
         totalCost += estimateCost(model, usage.inputTokens || 0, usage.outputTokens || 0, usage.cacheReadInputTokens || 0, usage.cacheCreationInputTokens || 0);
       }
@@ -5959,7 +6065,8 @@ async function readStatsCache() {
       cache_read_tokens: Math.round(totalCacheRead * share),
       cache_creation_tokens: Math.round(totalCacheCreation * share),
       cost_usd: Number((totalCost * share).toFixed(4)),
-      models
+      models,
+      cost_source: hasRealCost ? "real" : "estimated"
     });
   }
   return entries;
@@ -5984,226 +6091,569 @@ var claudeAdapter = {
 };
 
 // src/adapters/codex.ts
-import fs9 from "node:fs/promises";
-import path5 from "node:path";
-import os6 from "node:os";
-var HOME = os6.homedir();
-var CANDIDATE_DIRS = [
-  path5.join(HOME, ".codex", "usage"),
-  path5.join(HOME, ".openai-codex", "usage"),
-  path5.join(HOME, ".codex")
+import fs11 from "node:fs/promises";
+import path7 from "node:path";
+import os8 from "node:os";
+import { execFileSync as execFileSync2 } from "node:child_process";
+
+// src/lib/keys.ts
+import fs10 from "node:fs/promises";
+import path6 from "node:path";
+import os7 from "node:os";
+var KEYS_PATH = path6.join(os7.homedir(), ".awarts", "keys.json");
+async function ensureDir3() {
+  const dir = path6.dirname(KEYS_PATH);
+  await fs10.mkdir(dir, { recursive: true });
+}
+async function loadKeys() {
+  try {
+    const raw = await fs10.readFile(KEYS_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveKeys(keys) {
+  await ensureDir3();
+  await fs10.writeFile(KEYS_PATH, JSON.stringify(keys, null, 2), "utf-8");
+  try {
+    await fs10.chmod(KEYS_PATH, 384);
+  } catch {}
+}
+async function setKey(provider, key) {
+  const keys = await loadKeys();
+  keys[provider] = key;
+  await saveKeys(keys);
+}
+async function getKey(provider) {
+  const keys = await loadKeys();
+  return keys[provider];
+}
+async function removeKey(provider) {
+  const keys = await loadKeys();
+  if (!keys[provider])
+    return false;
+  delete keys[provider];
+  await saveKeys(keys);
+  return true;
+}
+async function listKeys() {
+  const keys = await loadKeys();
+  const result = [];
+  for (const [provider, key] of Object.entries(keys)) {
+    if (key) {
+      const masked = key.length > 8 ? key.slice(0, 4) + "..." + key.slice(-4) : "****";
+      result.push({ provider, masked });
+    }
+  }
+  return result;
+}
+
+// src/adapters/codex.ts
+var HOME = os8.homedir();
+var IS_WIN = process.platform === "win32";
+var LOCALAPPDATA = process.env.LOCALAPPDATA ?? path7.join(HOME, "AppData", "Local");
+var APPDATA = process.env.APPDATA ?? path7.join(HOME, "AppData", "Roaming");
+var LOCAL_DIRS = [
+  path7.join(HOME, ".codex", "usage"),
+  path7.join(HOME, ".openai-codex", "usage"),
+  path7.join(HOME, ".codex"),
+  path7.join(HOME, ".openai-codex"),
+  ...IS_WIN ? [
+    path7.join(LOCALAPPDATA, "codex", "usage"),
+    path7.join(LOCALAPPDATA, "openai-codex", "usage"),
+    path7.join(APPDATA, "codex", "usage"),
+    path7.join(APPDATA, "openai-codex", "usage"),
+    path7.join(LOCALAPPDATA, "codex"),
+    path7.join(APPDATA, "codex")
+  ] : []
+];
+var CONFIG_DIRS = [
+  path7.join(HOME, ".codex"),
+  path7.join(HOME, ".openai-codex"),
+  ...IS_WIN ? [
+    path7.join(LOCALAPPDATA, "codex"),
+    path7.join(APPDATA, "codex"),
+    path7.join(LOCALAPPDATA, "openai-codex"),
+    path7.join(APPDATA, "openai-codex")
+  ] : []
 ];
+var CODEX_PRICING = {
+  "gpt-5.4": { input: 2.5, output: 15 },
+  "gpt-5.4-pro": { input: 30, output: 180 },
+  "gpt-5.2": { input: 1.75, output: 14 },
+  "gpt-5.1": { input: 1.25, output: 10 },
+  "gpt-5": { input: 1.25, output: 10 },
+  "gpt-5-mini": { input: 0.25, output: 2 },
+  "gpt-5-nano": { input: 0.05, output: 0.4 },
+  "gpt-4.1": { input: 2, output: 8 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  o3: { input: 2, output: 8 },
+  "o3-pro": { input: 20, output: 80 },
+  "o4-mini": { input: 1.1, output: 4.4 },
+  o1: { input: 15, output: 60 },
+  "o1-pro": { input: 150, output: 600 },
+  "codex-mini": { input: 1.5, output: 6 },
+  "openai-codex": { input: 2, output: 8 }
+};
+var DEFAULT_PRICING2 = { input: 2, output: 8 };
+async function fetchOpenAICosts(apiKey) {
+  const entries = [];
+  const now = Math.floor(Date.now() / 1000);
+  const thirtyDaysAgo = now - 30 * 24 * 60 * 60;
+  let url = `https://api.openai.com/v1/organization/costs?start_time=${thirtyDaysAgo}&end_time=${now}&bucket_width=1d&limit=30`;
+  try {
+    while (url) {
+      const resp = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!resp.ok) {
+        return [];
+      }
+      const data = await resp.json();
+      for (const bucket of data.data) {
+        const date = new Date(bucket.start_time * 1000).toISOString().split("T")[0];
+        const totalCost = bucket.results.reduce((sum, r) => sum + r.amount.value, 0);
+        if (totalCost > 0) {
+          entries.push({
+            date,
+            provider: "codex",
+            cost_usd: totalCost / 100,
+            input_tokens: 0,
+            output_tokens: 0,
+            models: ["openai-codex"],
+            cost_source: "real"
+          });
+        }
+      }
+      url = data.has_more && data.next_page ? data.next_page : "";
+    }
+  } catch {
+    return [];
+  }
+  return entries;
+}
 function dateFromFilename(filename) {
   const match = filename.match(/^(\d{4}-\d{2}-\d{2})\.json$/);
   return match ? match[1] : null;
 }
 async function dirExists2(dir) {
   try {
-    const stat = await fs9.stat(dir);
+    const stat = await fs11.stat(dir);
     return stat.isDirectory();
   } catch {
     return false;
   }
 }
 async function findUsageDir() {
-  for (const dir of CANDIDATE_DIRS) {
+  for (const dir of LOCAL_DIRS) {
     if (await dirExists2(dir))
       return dir;
   }
   return null;
 }
+function commandExists(cmd) {
+  try {
+    execFileSync2(IS_WIN ? "where" : "which", [cmd], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readLocalFiles() {
+  const entries = [];
+  const dir = await findUsageDir();
+  if (!dir)
+    return entries;
+  let files;
+  try {
+    files = await fs11.readdir(dir);
+  } catch {
+    return entries;
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  for (const file of jsonFiles) {
+    try {
+      const filePath = path7.join(dir, file);
+      const raw = await fs11.readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      const date = data.date ?? dateFromFilename(file);
+      if (!date)
+        continue;
+      const costUsd = data.cost_usd ?? data.total_cost ?? 0;
+      const inputTokens = Number(data.input_tokens ?? 0) || 0;
+      const outputTokens = Number(data.output_tokens ?? 0) || 0;
+      const model = data.model ?? data.models?.[0];
+      let finalCost = Number(costUsd) || 0;
+      let costSource = finalCost > 0 ? "real" : "estimated";
+      if (finalCost === 0 && (inputTokens > 0 || outputTokens > 0)) {
+        const pricing = model && CODEX_PRICING[model] || DEFAULT_PRICING2;
+        finalCost = (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+        costSource = "estimated";
+      }
+      entries.push({
+        date,
+        provider: "codex",
+        cost_usd: finalCost,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_creation_tokens: Number(data.cache_creation_tokens ?? 0) || 0,
+        cache_read_tokens: Number(data.cache_read_tokens ?? 0) || 0,
+        models: data.models ?? (data.model ? [data.model] : []),
+        cost_source: costSource
+      });
+    } catch {}
+  }
+  return entries;
+}
+var SQLITE_PATHS = [
+  path7.join(HOME, ".codex", "state_5.sqlite"),
+  ...IS_WIN ? [
+    path7.join(LOCALAPPDATA, "codex", "state_5.sqlite"),
+    path7.join(APPDATA, "codex", "state_5.sqlite")
+  ] : []
+];
+async function findSqliteDb() {
+  for (const p of SQLITE_PATHS) {
+    try {
+      await fs11.access(p);
+      return p;
+    } catch {}
+  }
+  return null;
+}
+async function readSqliteThreads() {
+  const dbPath = await findSqliteDb();
+  if (!dbPath)
+    return [];
+  try {
+    const query = `SELECT date(created_at/1000000000, 'unixepoch') as day, tokens_used, model_provider FROM threads WHERE tokens_used > 0 ORDER BY created_at;`;
+    const result = execFileSync2("sqlite3", [dbPath, query], {
+      timeout: 5000,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!result)
+      return [];
+    const dayMap = new Map;
+    for (const line of result.split(`
+`)) {
+      const [day, tokensStr, model] = line.split("|");
+      if (!day)
+        continue;
+      const tokens2 = Number(tokensStr) || 0;
+      if (!dayMap.has(day))
+        dayMap.set(day, { tokens: 0, models: new Set });
+      const entry = dayMap.get(day);
+      entry.tokens += tokens2;
+      if (model)
+        entry.models.add(model);
+    }
+    const entries = [];
+    for (const [date, { tokens: tokens2, models }] of dayMap) {
+      const inputTokens = Math.round(tokens2 * 0.4);
+      const outputTokens = Math.round(tokens2 * 0.6);
+      const modelName = [...models][0] ?? "openai-codex";
+      const pricing = CODEX_PRICING[modelName] || DEFAULT_PRICING2;
+      const cost = (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+      entries.push({
+        date,
+        provider: "codex",
+        cost_usd: cost,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        models: [...models].length > 0 ? [...models] : ["openai-codex"],
+        cost_source: "estimated"
+      });
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
 var codexAdapter = {
   name: "codex",
-  displayName: "Codex",
+  displayName: "Codex (OpenAI)",
   async detect() {
-    return await findUsageDir() !== null;
+    const apiKey = await getKey("openai");
+    if (apiKey)
+      return true;
+    if (await findUsageDir() !== null)
+      return true;
+    if (await findSqliteDb() !== null)
+      return true;
+    for (const dir of CONFIG_DIRS) {
+      if (await dirExists2(dir))
+        return true;
+    }
+    if (commandExists("codex"))
+      return true;
+    return false;
   },
   async read() {
-    const entries = [];
-    const dir = await findUsageDir();
-    if (!dir)
-      return entries;
-    let files;
-    try {
-      files = await fs9.readdir(dir);
-    } catch {
-      return entries;
-    }
-    const jsonFiles = files.filter((f) => f.endsWith(".json"));
-    for (const file of jsonFiles) {
-      try {
-        const filePath = path5.join(dir, file);
-        const raw = await fs9.readFile(filePath, "utf-8");
-        const data = JSON.parse(raw);
-        const date = data.date ?? dateFromFilename(file);
-        if (!date)
-          continue;
-        const costUsd = data.cost_usd ?? data.total_cost ?? 0;
-        const inputTokens = data.input_tokens ?? 0;
-        const outputTokens = data.output_tokens ?? 0;
-        const models = data.models ? data.models : data.model ? [data.model] : [];
-        entries.push({
-          date,
-          provider: "codex",
-          cost_usd: Number(costUsd) || 0,
-          input_tokens: Number(inputTokens) || 0,
-          output_tokens: Number(outputTokens) || 0,
-          cache_creation_tokens: Number(data.cache_creation_tokens ?? 0) || 0,
-          cache_read_tokens: Number(data.cache_read_tokens ?? 0) || 0,
-          models
-        });
-      } catch {}
+    const apiKey = await getKey("openai");
+    if (apiKey) {
+      const apiEntries = await fetchOpenAICosts(apiKey);
+      if (apiEntries.length > 0)
+        return apiEntries;
     }
-    return entries;
+    const localEntries = await readLocalFiles();
+    if (localEntries.length > 0)
+      return localEntries;
+    return readSqliteThreads();
   }
 };
 
 // src/adapters/gemini.ts
-import fs10 from "node:fs/promises";
-import path6 from "node:path";
-import os7 from "node:os";
-var HOME2 = os7.homedir();
-var CANDIDATE_DIRS2 = [
-  path6.join(HOME2, ".gemini", "usage"),
-  path6.join(HOME2, ".config", "gemini", "usage"),
-  path6.join(HOME2, ".gemini")
+import fs12 from "node:fs/promises";
+import path8 from "node:path";
+import os9 from "node:os";
+import { execFileSync as execFileSync3 } from "node:child_process";
+var HOME2 = os9.homedir();
+var IS_WIN2 = process.platform === "win32";
+var LOCALAPPDATA2 = process.env.LOCALAPPDATA ?? path8.join(HOME2, "AppData", "Local");
+var LOCAL_DIRS2 = [
+  path8.join(HOME2, ".gemini", "usage"),
+  path8.join(HOME2, ".config", "gemini", "usage"),
+  ...IS_WIN2 ? [
+    path8.join(LOCALAPPDATA2, "gemini", "usage")
+  ] : []
+];
+var DETECT_DIRS = [
+  path8.join(HOME2, ".gemini"),
+  path8.join(HOME2, ".config", "gemini"),
+  ...IS_WIN2 ? [
+    path8.join(LOCALAPPDATA2, "gemini")
+  ] : []
 ];
+var GEMINI_PRICING = {
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+  "gemini-3.1-pro": { input: 2, output: 12 },
+  "gemini-3.1-flash-lite": { input: 0.25, output: 1.5 },
+  "gemini-3-flash": { input: 0.5, output: 3 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  "gemini-1.5-flash-8b": { input: 0.0375, output: 0.15 }
+};
+var DEFAULT_PRICING3 = { input: 0.3, output: 2.5 };
+function calculateCost(inputTokens, outputTokens, model) {
+  const pricing = model && GEMINI_PRICING[model] || DEFAULT_PRICING3;
+  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+}
 function dateFromFilename2(filename) {
   const match = filename.match(/^(\d{4}-\d{2}-\d{2})\.json$/);
   return match ? match[1] : null;
 }
 async function dirExists3(dir) {
   try {
-    const stat = await fs10.stat(dir);
+    const stat = await fs12.stat(dir);
     return stat.isDirectory();
   } catch {
     return false;
   }
 }
 async function findUsageDir2() {
-  for (const dir of CANDIDATE_DIRS2) {
+  for (const dir of LOCAL_DIRS2) {
     if (await dirExists3(dir))
       return dir;
   }
   return null;
 }
+function commandExists2(cmd) {
+  try {
+    execFileSync3(IS_WIN2 ? "where" : "which", [cmd], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readLocalFiles2() {
+  const entries = [];
+  const dir = await findUsageDir2();
+  if (!dir)
+    return entries;
+  let files;
+  try {
+    files = await fs12.readdir(dir);
+  } catch {
+    return entries;
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  for (const file of jsonFiles) {
+    try {
+      const filePath = path8.join(dir, file);
+      const raw = await fs12.readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      const date = data.date ?? dateFromFilename2(file);
+      if (!date)
+        continue;
+      const costUsd = data.cost_usd ?? data.total_cost ?? 0;
+      const inputTokens = Number(data.input_tokens ?? 0) || 0;
+      const outputTokens = Number(data.output_tokens ?? 0) || 0;
+      const model = data.model ?? data.models?.[0];
+      let finalCost = Number(costUsd) || 0;
+      let costSource = finalCost > 0 ? "real" : "estimated";
+      if (finalCost === 0 && (inputTokens > 0 || outputTokens > 0)) {
+        finalCost = calculateCost(inputTokens, outputTokens, model);
+        costSource = "estimated";
+      }
+      entries.push({
+        date,
+        provider: "gemini",
+        cost_usd: finalCost,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_creation_tokens: Number(data.cache_creation_tokens ?? 0) || 0,
+        cache_read_tokens: Number(data.cache_read_tokens ?? 0) || 0,
+        models: data.models ?? (data.model ? [data.model] : []),
+        cost_source: costSource
+      });
+    } catch {}
+  }
+  return entries;
+}
 var geminiAdapter = {
   name: "gemini",
   displayName: "Gemini",
   async detect() {
-    return await findUsageDir2() !== null;
+    const apiKey = await getKey("google");
+    if (apiKey)
+      return true;
+    for (const dir of DETECT_DIRS) {
+      if (await dirExists3(dir))
+        return true;
+    }
+    if (commandExists2("gemini"))
+      return true;
+    return false;
   },
   async read() {
-    const entries = [];
-    const dir = await findUsageDir2();
-    if (!dir)
-      return entries;
-    let files;
-    try {
-      files = await fs10.readdir(dir);
-    } catch {
-      return entries;
-    }
-    const jsonFiles = files.filter((f) => f.endsWith(".json"));
-    for (const file of jsonFiles) {
-      try {
-        const filePath = path6.join(dir, file);
-        const raw = await fs10.readFile(filePath, "utf-8");
-        const data = JSON.parse(raw);
-        const date = data.date ?? dateFromFilename2(file);
-        if (!date)
-          continue;
-        const costUsd = data.cost_usd ?? data.total_cost ?? 0;
-        const inputTokens = data.input_tokens ?? 0;
-        const outputTokens = data.output_tokens ?? 0;
-        const models = data.models ? data.models : data.model ? [data.model] : [];
-        entries.push({
-          date,
-          provider: "gemini",
-          cost_usd: Number(costUsd) || 0,
-          input_tokens: Number(inputTokens) || 0,
-          output_tokens: Number(outputTokens) || 0,
-          cache_creation_tokens: Number(data.cache_creation_tokens ?? 0) || 0,
-          cache_read_tokens: Number(data.cache_read_tokens ?? 0) || 0,
-          models
-        });
-      } catch {}
-    }
-    return entries;
+    return readLocalFiles2();
   }
 };
 
 // src/adapters/antigravity.ts
-import fs11 from "node:fs/promises";
-import path7 from "node:path";
-import os8 from "node:os";
-var HOME3 = os8.homedir();
-var CANDIDATE_DIRS3 = [
-  path7.join(HOME3, ".antigravity", "usage"),
-  path7.join(HOME3, ".antigravity")
+import fs13 from "node:fs/promises";
+import path9 from "node:path";
+import os10 from "node:os";
+var HOME3 = os10.homedir();
+var IS_WIN3 = process.platform === "win32";
+var LOCALAPPDATA3 = process.env.LOCALAPPDATA ?? path9.join(HOME3, "AppData", "Local");
+var LOCAL_DIRS3 = [
+  path9.join(HOME3, ".antigravity", "usage"),
+  path9.join(HOME3, ".antigravity"),
+  path9.join(HOME3, ".gemini", "antigravity", "usage"),
+  ...IS_WIN3 ? [
+    path9.join(LOCALAPPDATA3, "antigravity", "usage"),
+    path9.join(LOCALAPPDATA3, "antigravity")
+  ] : []
 ];
+var DETECT_DIRS2 = [
+  path9.join(HOME3, ".antigravity"),
+  path9.join(HOME3, ".gemini", "antigravity"),
+  ...IS_WIN3 ? [
+    path9.join(LOCALAPPDATA3, "antigravity")
+  ] : []
+];
+var ANTIGRAVITY_PRICING = {
+  "antigravity-1": { input: 3, output: 15 },
+  "antigravity-1.5": { input: 3, output: 15 },
+  "antigravity-2": { input: 3, output: 15 }
+};
+var DEFAULT_PRICING4 = { input: 3, output: 15 };
+function calculateCost2(inputTokens, outputTokens, model) {
+  const pricing = model && ANTIGRAVITY_PRICING[model] || DEFAULT_PRICING4;
+  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+}
 function dateFromFilename3(filename) {
   const match = filename.match(/^(\d{4}-\d{2}-\d{2})\.json$/);
   return match ? match[1] : null;
 }
 async function dirExists4(dir) {
   try {
-    const stat = await fs11.stat(dir);
+    const stat = await fs13.stat(dir);
     return stat.isDirectory();
   } catch {
     return false;
   }
 }
 async function findUsageDir3() {
-  for (const dir of CANDIDATE_DIRS3) {
+  for (const dir of LOCAL_DIRS3) {
     if (await dirExists4(dir))
       return dir;
   }
   return null;
 }
+async function readLocalFiles3() {
+  const entries = [];
+  const dir = await findUsageDir3();
+  if (!dir)
+    return entries;
+  let files;
+  try {
+    files = await fs13.readdir(dir);
+  } catch {
+    return entries;
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  for (const file of jsonFiles) {
+    try {
+      const filePath = path9.join(dir, file);
+      const raw = await fs13.readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      const date = data.date ?? dateFromFilename3(file);
+      if (!date)
+        continue;
+      const costUsd = data.cost_usd ?? data.total_cost ?? 0;
+      const inputTokens = Number(data.input_tokens ?? 0) || 0;
+      const outputTokens = Number(data.output_tokens ?? 0) || 0;
+      const model = data.model ?? data.models?.[0];
+      let finalCost = Number(costUsd) || 0;
+      let costSource = finalCost > 0 ? "real" : "estimated";
+      if (finalCost === 0 && (inputTokens > 0 || outputTokens > 0)) {
+        finalCost = calculateCost2(inputTokens, outputTokens, model);
+        costSource = "estimated";
+      }
+      entries.push({
+        date,
+        provider: "antigravity",
+        cost_usd: finalCost,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_creation_tokens: Number(data.cache_creation_tokens ?? 0) || 0,
+        cache_read_tokens: Number(data.cache_read_tokens ?? 0) || 0,
+        models: data.models ?? (data.model ? [data.model] : []),
+        cost_source: costSource
+      });
+    } catch {}
+  }
+  return entries;
+}
 var antigravityAdapter = {
   name: "antigravity",
   displayName: "Antigravity",
   async detect() {
-    return await findUsageDir3() !== null;
+    const apiKey = await getKey("antigravity");
+    if (apiKey)
+      return true;
+    for (const dir of DETECT_DIRS2) {
+      if (await dirExists4(dir))
+        return true;
+    }
+    return false;
   },
   async read() {
-    const entries = [];
-    const dir = await findUsageDir3();
-    if (!dir)
-      return entries;
-    let files;
-    try {
-      files = await fs11.readdir(dir);
-    } catch {
-      return entries;
-    }
-    const jsonFiles = files.filter((f) => f.endsWith(".json"));
-    for (const file of jsonFiles) {
-      try {
-        const filePath = path7.join(dir, file);
-        const raw = await fs11.readFile(filePath, "utf-8");
-        const data = JSON.parse(raw);
-        const date = data.date ?? dateFromFilename3(file);
-        if (!date)
-          continue;
-        const costUsd = data.cost_usd ?? data.total_cost ?? 0;
-        const inputTokens = data.input_tokens ?? 0;
-        const outputTokens = data.output_tokens ?? 0;
-        const models = data.models ? data.models : data.model ? [data.model] : [];
-        entries.push({
-          date,
-          provider: "antigravity",
-          cost_usd: Number(costUsd) || 0,
-          input_tokens: Number(inputTokens) || 0,
-          output_tokens: Number(outputTokens) || 0,
-          cache_creation_tokens: Number(data.cache_creation_tokens ?? 0) || 0,
-          cache_read_tokens: Number(data.cache_read_tokens ?? 0) || 0,
-          models
-        });
-      } catch {}
-    }
-    return entries;
+    return readLocalFiles3();
   }
 };
 
@@ -6319,9 +6769,10 @@ async function pushCommand(opts) {
   const hash = hashEntries(allEntries);
   const spin = spinner("Submitting usage data...");
   spin.start();
+  const cleanEntries = allEntries.map(({ cost_source, ...rest }) => rest);
   try {
     const res = await post("/api/usage/submit", {
-      entries: allEntries,
+      entries: cleanEntries,
       source: "cli",
       hash
     });
@@ -6456,6 +6907,16 @@ async function syncCommand() {
       const entries = await adapter.read();
       if (entries.length === 0) {
         spin.info(source_default.dim(`${adapter.displayName} -- no usage data found`));
+        if (adapter.name === "codex") {
+          dim(`    Set your OpenAI API key:  ${source_default.cyan("awarts keys set openai <your-key>")}`);
+          dim(`    Or create usage files manually — see ${source_default.cyan("awarts.com/docs")}`);
+        } else if (adapter.name === "gemini") {
+          dim(`    Set your Google API key:  ${source_default.cyan("awarts keys set google <your-key>")}`);
+          dim(`    Or create usage files manually — see ${source_default.cyan("awarts.com/docs")}`);
+        } else if (adapter.name === "antigravity") {
+          dim(`    Set your API key:  ${source_default.cyan("awarts keys set antigravity <your-key>")}`);
+          dim(`    Or create usage files manually — see ${source_default.cyan("awarts.com/docs")}`);
+        }
       } else {
         allEntries.push(...entries);
         const totalCost2 = entries.reduce((s, e) => s + e.cost_usd, 0);
@@ -6470,6 +6931,12 @@ async function syncCommand() {
   if (allEntries.length === 0) {
     warn("No usage data found across any provider.");
     console.log();
+    info(`Set API keys to fetch real billing data:`);
+    dim(`  ${source_default.cyan("awarts keys set openai <key>")}      — for Codex / OpenAI`);
+    dim(`  ${source_default.cyan("awarts keys set google <key>")}      — for Gemini`);
+    dim(`  ${source_default.cyan("awarts keys set antigravity <key>")} — for Antigravity`);
+    dim(`Or visit ${source_default.cyan("awarts.com/docs")} for manual import instructions.`);
+    console.log();
     return;
   }
   const totalCost = allEntries.reduce((s, e) => s + e.cost_usd, 0);
@@ -6485,9 +6952,10 @@ async function syncCommand() {
   const hash = hashEntries(allEntries);
   const submitSpin = spinner("Syncing with AWARTS...");
   submitSpin.start();
+  const cleanEntries = allEntries.map(({ cost_source, ...rest }) => rest);
   try {
     const res = await post("/api/usage/submit", {
-      entries: allEntries,
+      entries: cleanEntries,
       source: "cli",
       hash
     });
@@ -6518,6 +6986,16 @@ async function syncCommand() {
     console.log();
     success("Your usage data is now live on AWARTS.");
     console.log();
+    try {
+      const existingPid = await readPid();
+      const isRunning = existingPid ? isProcessRunning(existingPid) : false;
+      if (!isRunning) {
+        const pid = await spawnDaemon(DEFAULT_INTERVAL_MS);
+        dim(`Auto-sync daemon started (PID ${pid}, every 5 min)`);
+        dim("Manage with:  awarts daemon status | stop | logs");
+        console.log();
+      }
+    } catch {}
   } catch (err) {
     submitSpin.fail("Could not reach the AWARTS server.");
     error(err instanceof Error ? err.message : String(err));
@@ -6525,87 +7003,119 @@ async function syncCommand() {
   }
 }
 
-// src/lib/daemon.ts
-import fs12 from "node:fs/promises";
-import { openSync } from "node:fs";
-import path8 from "node:path";
-import os9 from "node:os";
-import { spawn } from "node:child_process";
-var AWARTS_DIR2 = path8.join(os9.homedir(), ".awarts");
-var PID_FILE = path8.join(AWARTS_DIR2, "daemon.pid");
-var LOG_FILE = path8.join(AWARTS_DIR2, "daemon.log");
-var DEFAULT_INTERVAL_MS = 5 * 60 * 1000;
-async function ensureDir2() {
-  await fs12.mkdir(AWARTS_DIR2, { recursive: true });
+// src/commands/seed.ts
+import fs14 from "node:fs/promises";
+import path10 from "node:path";
+import os11 from "node:os";
+var HOME4 = os11.homedir();
+var IS_WIN4 = process.platform === "win32";
+var LOCALAPPDATA4 = process.env.LOCALAPPDATA ?? path10.join(HOME4, "AppData", "Local");
+var PROVIDER_USAGE_DIRS = {
+  codex: IS_WIN4 ? path10.join(LOCALAPPDATA4, "codex", "usage") : path10.join(HOME4, ".codex", "usage"),
+  gemini: IS_WIN4 ? path10.join(LOCALAPPDATA4, "gemini", "usage") : path10.join(HOME4, ".gemini", "usage"),
+  antigravity: IS_WIN4 ? path10.join(LOCALAPPDATA4, "antigravity", "usage") : path10.join(HOME4, ".antigravity", "usage")
+};
+var SAMPLE_MODELS = {
+  codex: ["gpt-4.1", "gpt-4.1-mini", "o4-mini"],
+  gemini: ["gemini-2.5-flash", "gemini-2.5-pro"],
+  antigravity: ["antigravity-1.5"]
+};
+var TOKEN_RANGES = {
+  codex: { inputMin: 8000, inputMax: 45000, outputMin: 2000, outputMax: 18000 },
+  gemini: { inputMin: 5000, inputMax: 35000, outputMin: 1500, outputMax: 12000 },
+  antigravity: { inputMin: 1e4, inputMax: 50000, outputMin: 3000, outputMax: 20000 }
+};
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
 }
-async function readPid() {
-  try {
-    const raw = await fs12.readFile(PID_FILE, "utf-8");
-    const pid = parseInt(raw.trim(), 10);
-    return isNaN(pid) ? null : pid;
-  } catch {
-    return null;
+function generateSampleEntries(provider, days) {
+  const models = SAMPLE_MODELS[provider] ?? ["unknown"];
+  const ranges = TOKEN_RANGES[provider] ?? { inputMin: 5000, inputMax: 30000, outputMin: 2000, outputMax: 15000 };
+  const entries = [];
+  const now = new Date;
+  for (let i = 0;i < days; i++) {
+    const date = new Date(now);
+    date.setDate(date.getDate() - i);
+    const dateStr = date.toISOString().split("T")[0];
+    if (i > 0 && Math.random() < 0.3)
+      continue;
+    const model = models[randomInt(0, models.length - 1)];
+    const inputTokens = randomInt(ranges.inputMin, ranges.inputMax);
+    const outputTokens = randomInt(ranges.outputMin, ranges.outputMax);
+    entries.push({
+      date: dateStr,
+      data: {
+        date: dateStr,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        model,
+        models: [model]
+      }
+    });
   }
+  return entries;
 }
-async function writePid(pid) {
-  await ensureDir2();
-  await fs12.writeFile(PID_FILE, String(pid), "utf-8");
-}
-async function removePid() {
-  try {
-    await fs12.unlink(PID_FILE);
-  } catch {}
-}
-function isProcessRunning(pid) {
+async function dirExists5(dir) {
   try {
-    process.kill(pid, 0);
-    return true;
+    const stat = await fs14.stat(dir);
+    return stat.isDirectory();
   } catch {
     return false;
   }
 }
-function killProcess(pid) {
+async function hasExistingData(dir) {
+  if (!await dirExists5(dir))
+    return false;
   try {
-    process.kill(pid, "SIGTERM");
-    return true;
+    const files = await fs14.readdir(dir);
+    return files.some((f) => f.endsWith(".json"));
   } catch {
     return false;
   }
 }
-async function appendLog(message) {
-  await ensureDir2();
-  const timestamp = new Date().toISOString();
-  const line = `[${timestamp}] ${message}
-`;
-  await fs12.appendFile(LOG_FILE, line, "utf-8");
-}
-async function readLogTail(lines = 50) {
-  try {
-    const content = await fs12.readFile(LOG_FILE, "utf-8");
-    const allLines = content.split(`
-`).filter(Boolean);
-    return allLines.slice(-lines).join(`
-`);
-  } catch {
-    return "(no log file found)";
+async function seedCommand(opts) {
+  banner();
+  const days = opts.days ?? 7;
+  const providers = opts.provider ? [opts.provider] : Object.keys(PROVIDER_USAGE_DIRS);
+  let seeded = 0;
+  for (const provider of providers) {
+    const usageDir = PROVIDER_USAGE_DIRS[provider];
+    if (!usageDir) {
+      warn(`Unknown provider: ${provider}`);
+      continue;
+    }
+    if (!opts.force && await hasExistingData(usageDir)) {
+      info(`${source_default.bold(provider)} already has usage data in ${source_default.dim(usageDir)}`);
+      dim("  Use --force to overwrite existing data");
+      continue;
+    }
+    const spin = spinner(`Generating ${provider} sample data...`);
+    spin.start();
+    try {
+      await fs14.mkdir(usageDir, { recursive: true });
+      const entries = generateSampleEntries(provider, days);
+      for (const entry of entries) {
+        const filePath = path10.join(usageDir, `${entry.date}.json`);
+        await fs14.writeFile(filePath, JSON.stringify(entry.data, null, 2), "utf-8");
+      }
+      spin.succeed(`${providerLabel(provider)}  ${source_default.bold(String(entries.length))} sample files written to ${source_default.dim(usageDir)}`);
+      seeded++;
+    } catch (err) {
+      spin.fail(`Failed to seed ${provider}`);
+      error(err instanceof Error ? err.message : String(err));
+    }
   }
-}
-async function spawnDaemon(intervalMs) {
-  await ensureDir2();
-  const cliScript = process.argv[1];
-  const logFd = openSync(LOG_FILE, "a");
-  const child = spawn(process.execPath, [cliScript, "daemon", "__run", "--interval", String(intervalMs)], {
-    detached: true,
-    stdio: ["ignore", logFd, logFd],
-    env: { ...process.env }
-  });
-  child.unref();
-  const pid = child.pid;
-  if (!pid) {
-    throw new Error("Failed to spawn daemon process");
+  console.log();
+  if (seeded > 0) {
+    success(`Sample data generated! Run ${source_default.cyan("awarts sync")} to push it to AWARTS.`);
+    console.log();
+    dim("Note: Seed data uses estimated costs based on token counts and model pricing.");
+    dim("For real billing data, set up API keys: awarts keys set <provider> <key>");
+  } else {
+    info("No providers needed seeding. All providers already have data.");
+    dim(`Use ${source_default.cyan("--force")} to regenerate sample data.`);
   }
-  await writePid(pid);
-  return pid;
+  console.log();
 }
 
 // src/commands/daemon.ts
@@ -6714,9 +7224,41 @@ async function daemonRunLoop(intervalMs) {
   }
 }
 
+// src/lib/version-check.ts
+import { readFileSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname, join } from "node:path";
+var __dirname3 = dirname(fileURLToPath2(import.meta.url));
+function getLocalVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname3, "..", "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function checkForUpdates() {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const res = await fetch("https://registry.npmjs.org/awarts/latest", {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok)
+      return;
+    const data = await res.json();
+    const latest = data.version;
+    const current = getLocalVersion();
+    if (latest && latest !== current) {
+      info(`Update available: ${current} → ${latest}. Run: npm i -g awarts@latest`);
+    }
+  } catch {}
+}
+
 // src/index.ts
 var program2 = new Command;
-program2.name("awarts").description("Track your AI coding spend across Claude, Codex, Gemini & Antigravity").version("0.1.0");
+program2.name("awarts").description("Track your AI coding spend across Claude, Codex, Gemini & Antigravity").version("0.2.5").hook("preAction", () => checkForUpdates());
 program2.command("login").description("Authenticate with your AWARTS account via device auth").option("--force", "Re-authenticate even if already logged in").action(async (opts) => {
   try {
     if (opts.force) {
@@ -6745,6 +7287,18 @@ program2.command("sync").description("Auto-detect all providers and push usage d
     process.exit(1);
   }
 });
+program2.command("seed").description("Generate sample usage data for providers with no data (Codex, Gemini, Antigravity)").option("-p, --provider <name>", "Only seed a specific provider (codex, gemini, antigravity)").option("-d, --days <count>", "Number of days of sample data to generate", "7").option("--force", "Overwrite existing usage data").action(async (opts) => {
+  try {
+    await seedCommand({
+      provider: opts.provider,
+      days: Number(opts.days) || 7,
+      force: opts.force
+    });
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
 program2.command("status").description("Show auth status, configuration, and detected providers").action(async () => {
   try {
     await statusCommand();
@@ -6807,6 +7361,56 @@ daemon.command("__run", { hidden: true }).option("--interval <ms>", "Interval in
     process.exit(1);
   }
 });
+var keys = program2.command("keys").description("Manage API keys for provider billing (OpenAI, Google, Antigravity)");
+keys.command("set <provider> <key>").description("Store an API key for a provider (openai, google, antigravity)").action(async (provider, key) => {
+  try {
+    const valid = ["openai", "google", "antigravity"];
+    if (!valid.includes(provider)) {
+      error(`Invalid provider "${provider}". Must be one of: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+    await setKey(provider, key);
+    success(`API key saved for ${provider} (stored in ~/.awarts/keys.json)`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+keys.command("list").description("List stored API keys (masked)").action(async () => {
+  try {
+    const stored = await listKeys();
+    if (stored.length === 0) {
+      info("No API keys stored. Use `awarts keys set <provider> <key>` to add one.");
+      return;
+    }
+    console.log();
+    for (const { provider, masked } of stored) {
+      console.log(`  ${provider.padEnd(14)} ${masked}`);
+    }
+    console.log();
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+keys.command("remove <provider>").description("Remove a stored API key").action(async (provider) => {
+  try {
+    const valid = ["openai", "google", "antigravity"];
+    if (!valid.includes(provider)) {
+      error(`Invalid provider "${provider}". Must be one of: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+    const removed = await removeKey(provider);
+    if (removed) {
+      success(`API key removed for ${provider}`);
+    } else {
+      info(`No key stored for ${provider}`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
 program2.parseAsync(process.argv).catch((err) => {
   error(err instanceof Error ? err.message : String(err));
   process.exit(1);