opencode-usage 0.4.8 → 0.5.0

package/dist/index.js

@@ -1,5 +1,754 @@
 #!/usr/bin/env bun
 // @bun
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/commander/services/command-runner.ts
+function registerCommand(spec) {
+  if (registry.has(spec.id)) {
+    throw new Error(`Command "${spec.id}" is already registered`);
+  }
+  registry.set(spec.id, spec);
+}
+function getJob(jobId) {
+  return jobs.get(jobId);
+}
+function runCommand(commandId, payload) {
+  const spec = registry.get(commandId);
+  if (!spec) {
+    throw new Error(`Unknown command: "${commandId}"`);
+  }
+  const input = spec.validateInput(payload);
+  const jobId = crypto.randomUUID();
+  const job = {
+    id: jobId,
+    commandId,
+    status: "queued",
+    logs: []
+  };
+  jobs.set(jobId, job);
+  const ctx = {
+    jobId,
+    log(level, message) {
+      job.logs.push({ ts: new Date().toISOString(), level, message });
+    }
+  };
+  executeJob(job, ctx, spec, input);
+  return jobId;
+}
+async function executeJob(job, ctx, spec, input) {
+  job.status = "running";
+  job.startedAt = new Date().toISOString();
+  ctx.log("info", `Running command "${job.commandId}"`);
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    if (job.status === "running") {
+      job.status = "failed";
+      job.finishedAt = new Date().toISOString();
+      job.error = {
+        code: "TIMEOUT",
+        message: `Command "${job.commandId}" timed out after ${spec.timeoutMs}ms`
+      };
+      ctx.log("error", `Timeout after ${spec.timeoutMs}ms`);
+    }
+  }, spec.timeoutMs);
+  try {
+    const result = await spec.run(ctx, input);
+    if (timedOut)
+      return;
+    clearTimeout(timer);
+    job.status = "success";
+    job.finishedAt = new Date().toISOString();
+    job.result = result;
+    ctx.log("info", "Command completed successfully");
+  } catch (err) {
+    if (timedOut)
+      return;
+    clearTimeout(timer);
+    const message = err instanceof Error ? err.message : "Unknown runtime error";
+    job.status = "failed";
+    job.finishedAt = new Date().toISOString();
+    job.error = { code: "RUNTIME_ERROR", message };
+    ctx.log("error", message);
+  }
+}
+var registry, jobs;
+var init_command_runner = __esm(() => {
+  registry = new Map;
+  jobs = new Map;
+});
+
+// src/commander/services/config-service.ts
+import { homedir as homedir5 } from "os";
+import { join as join7, basename as basename2 } from "path";
+import { rename, mkdir, copyFile, readdir, stat } from "fs/promises";
+import { readFileSync } from "fs";
+function isValidSource(s) {
+  return VALID_SOURCES.has(s);
+}
+function configPath(source) {
+  return join7(CONFIG_DIR, SOURCE_FILENAMES[source]);
+}
+async function fileExists(path2) {
+  try {
+    await stat(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readFileTextSync(path2) {
+  return readFileSync(path2, "utf-8");
+}
+async function writeFileText(path2, content) {
+  if (isBun3) {
+    await Bun.write(path2, content);
+    return;
+  }
+  const { writeFile } = await import("fs/promises");
+  await writeFile(path2, content, "utf-8");
+}
+function getCached(path2) {
+  const entry = configCache.get(path2);
+  if (entry && Date.now() < entry.expiry)
+    return entry.data;
+  return;
+}
+function setCache(path2, data) {
+  configCache.set(path2, { data, expiry: Date.now() + CONFIG_CACHE_TTL });
+}
+function invalidateCache(source) {
+  configCache.delete(configPath(source));
+}
+async function listConfigFiles() {
+  const sources = Object.keys(SOURCE_FILENAMES);
+  const results = [];
+  for (const source of sources) {
+    const path2 = configPath(source);
+    let exists = false;
+    let parseOk = false;
+    let sizeBytes = 0;
+    try {
+      const s = await stat(path2);
+      exists = true;
+      sizeBytes = s.size;
+      const raw = readFileTextSync(path2);
+      JSON.parse(raw);
+      parseOk = true;
+    } catch {
+    }
+    results.push({ source, path: path2, exists, parseOk, sizeBytes });
+  }
+  return results;
+}
+function readConfig(source) {
+  const path2 = configPath(source);
+  const cached = getCached(path2);
+  if (cached !== undefined)
+    return cached;
+  let raw;
+  try {
+    raw = readFileTextSync(path2);
+  } catch {
+    throw new ConfigError(`Config file not found: ${path2}`, 404);
+  }
+  try {
+    const result = JSON.parse(raw);
+    setCache(path2, result);
+    return result;
+  } catch {
+    throw new ConfigError(`Config file is not valid JSON: ${basename2(path2)}`, 422);
+  }
+}
+async function writeConfig(source, data) {
+  const path2 = configPath(source);
+  const backupPath = await createBackup(source);
+  const tmpPath = `${path2}.tmp`;
+  const content = JSON.stringify(data, null, 2) + "\n";
+  await writeFileText(tmpPath, content);
+  await rename(tmpPath, path2);
+  invalidateCache(source);
+  return { backupPath };
+}
+async function rollbackConfig(source) {
+  const latest = await findLatestBackup(source);
+  if (!latest) {
+    throw new ConfigError(`No backup found for source: ${source}`, 404);
+  }
+  const path2 = configPath(source);
+  const tmpPath = `${path2}.tmp`;
+  await copyFile(latest, tmpPath);
+  await rename(tmpPath, path2);
+  return { restoredFrom: latest };
+}
+async function createBackup(source) {
+  const path2 = configPath(source);
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = join7(BACKUP_ROOT, timestamp);
+  await mkdir(backupDir, { recursive: true });
+  const backupFile = join7(backupDir, SOURCE_FILENAMES[source]);
+  if (await fileExists(path2)) {
+    await copyFile(path2, backupFile);
+  } else {
+    await writeFileText(backupFile, "null\n");
+  }
+  return backupFile;
+}
+async function findLatestBackup(source) {
+  if (!await fileExists(BACKUP_ROOT))
+    return null;
+  const entries = await readdir(BACKUP_ROOT);
+  const sorted = entries.sort();
+  for (let i = sorted.length - 1;i >= 0; i--) {
+    const candidate = join7(BACKUP_ROOT, sorted[i], SOURCE_FILENAMES[source]);
+    if (await fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+var isBun3, CONFIG_DIR, BACKUP_ROOT, SOURCE_FILENAMES, VALID_SOURCES, CONFIG_CACHE_TTL = 2000, configCache, ConfigError;
+var init_config_service = __esm(() => {
+  isBun3 = typeof globalThis.Bun !== "undefined";
+  CONFIG_DIR = join7(homedir5(), ".config", "opencode");
+  BACKUP_ROOT = join7(CONFIG_DIR, "commander-backups");
+  SOURCE_FILENAMES = {
+    "codex-multi-account-accounts": "codex-multi-account-accounts.json",
+    "anthropic-multi-account-state": "anthropic-multi-account-state.json",
+    "antigravity-accounts": "antigravity-accounts.json",
+    opencode: "opencode.json"
+  };
+  VALID_SOURCES = new Set(Object.keys(SOURCE_FILENAMES));
+  configCache = new Map;
+  ConfigError = class ConfigError extends Error {
+    status;
+    constructor(message, status) {
+      super(message);
+      this.name = "ConfigError";
+      this.status = status;
+    }
+  };
+});
+
+// src/commander/services/plugin-adapters.ts
+var exports_plugin_adapters = {};
+import { homedir as homedir6, tmpdir } from "os";
+import { join as join8 } from "path";
+function resolveSource2(provider) {
+  const source = PROVIDER_SOURCE[provider];
+  if (!source) {
+    throw new Error(`Unknown provider "${provider}". Valid: ${Object.keys(PROVIDER_SOURCE).join(", ")}`);
+  }
+  return source;
+}
+async function readCredentialFile(filename) {
+  const filePath = join8(homedir6(), ".config", "opencode", filename);
+  const text = await Bun.file(filePath).text();
+  return JSON.parse(text);
+}
+async function spawnPluginCli(command, args, timeoutMs = 15000) {
+  const localBin = `./node_modules/${command}/dist/cli.js`;
+  const useLocal = await Bun.file(localBin).exists();
+  if (!useLocal) {
+    const existing = bunxBarrier.get(command);
+    if (existing) {
+      await existing.catch(() => {
+      });
+      return runPluginCli(command, args, timeoutMs, false);
+    }
+    const warmup = runPluginCli(command, args, timeoutMs, false);
+    const barrier = warmup.then(() => {
+    }, () => {
+    });
+    bunxBarrier.set(command, barrier);
+    barrier.finally(() => bunxBarrier.delete(command));
+    return warmup;
+  }
+  return runPluginCli(command, args, timeoutMs, true);
+}
+async function runPluginCli(command, args, timeoutMs, useLocal) {
+  const t0 = Date.now();
+  const localBin = `./node_modules/${command}/dist/cli.js`;
+  const cmd = useLocal ? ["bun", localBin, ...args] : ["bunx", `${command}@latest`, ...args];
+  const cwd = useLocal ? undefined : join8(tmpdir(), `bunx-${crypto.randomUUID()}`);
+  if (cwd)
+    await Bun.$`mkdir -p ${cwd}`.quiet();
+  console.log(`[spawnPluginCli] starting: ${cmd.join(" ")}`);
+  const proc = Bun.spawn(cmd, {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, NO_COLOR: "1" },
+    cwd
+  });
+  const timer = setTimeout(() => {
+    console.log(`[spawnPluginCli] killing after ${timeoutMs}ms`);
+    proc.kill();
+  }, timeoutMs);
+  try {
+    const [stdout, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      proc.exited
+    ]);
+    const elapsed = Date.now() - t0;
+    console.log(`[spawnPluginCli] exited ${exitCode} in ${elapsed}ms, stdout=${stdout.length}b`);
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      console.log(`[spawnPluginCli] stderr: ${stderr.slice(0, 300)}`);
+      throw new Error(`${command} exited with code ${exitCode}: ${(stderr || stdout).slice(0, 300)}`);
+    }
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    for (let i = lines.length - 1;i >= 0; i--) {
+      try {
+        const parsed = JSON.parse(lines[i]);
+        console.log(`[spawnPluginCli] parsed:`, parsed);
+        return parsed;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`No JSON output from ${command}: ${stdout.slice(0, 200)}`);
+  } finally {
+    clearTimeout(timer);
+    if (cwd)
+      Bun.$`rm -rf ${cwd}`.quiet().catch(() => {
+      });
+  }
+}
+async function clearStaleMetrics(provider, alias) {
+  console.log(`[clearStaleMetrics] checking ${provider}/${alias}`);
+  try {
+    const source = resolveSource2(provider);
+    const data = await readConfig(source);
+    const now = Date.now();
+    let changed = false;
+    switch (provider) {
+      case "anthropic": {
+        const usage = data.usage ?? {};
+        const acct = usage[alias];
+        if (acct) {
+          for (const key of ["session5h", "weekly7d", "weekly7dSonnet"]) {
+            const m2 = acct[key];
+            if (m2 && typeof m2.reset === "number" && m2.reset < now / 1000) {
+              m2.utilization = 0;
+              m2.status = "active";
+              delete m2.reset;
+              changed = true;
+            }
+          }
+        }
+        break;
+      }
+      case "codex": {
+        const accounts = data.accounts ?? {};
+        const acct = accounts[alias];
+        if (acct?.rateLimits) {
+          const rl = acct.rateLimits;
+          for (const key of ["fiveHour", "weekly"]) {
+            const w2 = rl[key];
+            if (w2?.resetAt && typeof w2.resetAt === "string") {
+              if (new Date(w2.resetAt).getTime() < now) {
+                w2.remaining = w2.limit;
+                delete w2.resetAt;
+                changed = true;
+              }
+            }
+          }
+        }
+        break;
+      }
+      case "antigravity": {
+        const accounts = Array.isArray(data.accounts) ? data.accounts : [];
+        const acct = accounts.find((a) => a.email === alias);
+        if (acct?.cachedQuota) {
+          const quota = acct.cachedQuota;
+          for (const group of Object.keys(quota)) {
+            const q2 = quota[group];
+            if (q2.resetTime && typeof q2.resetTime === "string") {
+              if (new Date(q2.resetTime).getTime() < now) {
+                q2.remainingFraction = 1;
+                delete q2.resetTime;
+                changed = true;
+              }
+            }
+          }
+        }
+        break;
+      }
+    }
+    if (changed) {
+      console.log(`[clearStaleMetrics] cleared stale data for ${provider}/${alias}`);
+      await writeConfig(source, data);
+    } else {
+      console.log(`[clearStaleMetrics] no stale data found for ${provider}/${alias}`);
+    }
+  } catch (err) {
+    console.log(`[clearStaleMetrics] error for ${provider}/${alias}:`, err);
+  }
+}
+function reauthCliCommand(provider) {
+  const cmd = REAUTH_PROVIDERS[provider];
+  if (!cmd)
+    throw new Error(`Re-auth not supported for provider: ${provider}`);
+  return cmd;
+}
+var isBun4, PROVIDER_SOURCE, bunxBarrier, REAUTH_PROVIDERS;
+var init_plugin_adapters = __esm(() => {
+  init_command_runner();
+  init_config_service();
+  isBun4 = typeof globalThis.Bun !== "undefined";
+  PROVIDER_SOURCE = {
+    anthropic: "anthropic-multi-account-state",
+    codex: "codex-multi-account-accounts",
+    antigravity: "antigravity-accounts"
+  };
+  registerCommand({
+    id: "accounts.add",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("accounts.add requires a non-empty 'provider' string");
+      }
+      if (typeof p.alias !== "string" || !p.alias) {
+        throw new Error("accounts.add requires a non-empty 'alias' string");
+      }
+      return { provider: p.provider, alias: p.alias };
+    },
+    async run(ctx, input) {
+      ctx.log("info", `Adding account "${input.alias}" for provider "${input.provider}"`);
+      ctx.log("info", "OAuth authentication requires terminal interaction \u2014 run this command from the CLI.");
+      return {
+        message: `Account "${input.alias}" for provider "${input.provider}" requires terminal-based OAuth. Please run: opencode-usage accounts add --provider ${input.provider} --alias ${input.alias}`,
+        requiresTerminal: true
+      };
+    }
+  });
+  registerCommand({
+    id: "accounts.remove",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("accounts.remove requires a non-empty 'provider' string");
+      }
+      if (typeof p.alias !== "string" || !p.alias) {
+        throw new Error("accounts.remove requires a non-empty 'alias' string");
+      }
+      return { provider: p.provider, alias: p.alias };
+    },
+    async run(ctx, input) {
+      const source = resolveSource2(input.provider);
+      ctx.log("info", `Removing account "${input.alias}" from ${source}`);
+      const data = await readConfig(source);
+      const accounts = data.accounts ?? {};
+      delete accounts[input.alias];
+      data.accounts = accounts;
+      await writeConfig(source, data);
+      ctx.log("info", `Account "${input.alias}" removed successfully`);
+      return { ok: true };
+    }
+  });
+  registerCommand({
+    id: "accounts.switch",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("accounts.switch requires a non-empty 'provider' string");
+      }
+      if (typeof p.alias !== "string" || !p.alias) {
+        throw new Error("accounts.switch requires a non-empty 'alias' string");
+      }
+      return { provider: p.provider, alias: p.alias };
+    },
+    async run(ctx, input) {
+      const source = resolveSource2(input.provider);
+      ctx.log("info", `Switching active account to "${input.alias}" in ${source}`);
+      const data = await readConfig(source);
+      switch (input.provider) {
+        case "anthropic":
+          data.currentAccount = input.alias;
+          break;
+        case "codex":
+          data.activeAlias = input.alias;
+          break;
+        case "antigravity": {
+          const accounts = Array.isArray(data.accounts) ? data.accounts : [];
+          const idx = accounts.findIndex((a) => typeof a.email === "string" && a.email === input.alias);
+          if (idx === -1) {
+            throw new Error(`Account "${input.alias}" not found in antigravity`);
+          }
+          data.activeIndex = idx;
+          break;
+        }
+        default:
+          throw new Error(`Unknown provider: ${input.provider}`);
+      }
+      await writeConfig(source, data);
+      ctx.log("info", `Active account set to "${input.alias}"`);
+      return { ok: true };
+    }
+  });
+  bunxBarrier = new Map;
+  registerCommand({
+    id: "accounts.ping",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("accounts.ping requires a non-empty 'provider' string");
+      }
+      if (typeof p.alias !== "string" || !p.alias) {
+        throw new Error("accounts.ping requires a non-empty 'alias' string");
+      }
+      return { provider: p.provider, alias: p.alias };
+    },
+    async run(ctx, input) {
+      ctx.log("info", `Pinging ${input.provider} account "${input.alias}"\u2026`);
+      switch (input.provider) {
+        case "anthropic": {
+          ctx.log("info", "Calling oc-anthropic-multi-account ping\u2026");
+          const result = await spawnPluginCli("oc-anthropic-multi-account", [
+            "ping",
+            input.alias
+          ]);
+          const status = String(result.status ?? "error");
+          ctx.log("info", `Result: ${status}`);
+          if (status === "ok") {
+            await clearStaleMetrics(input.provider, input.alias);
+          }
+          return {
+            status,
+            message: status === "ok" ? "pong" : String(result.error ?? "unknown error")
+          };
+        }
+        case "codex": {
+          ctx.log("info", "Calling oc-codex-multi-account ping\u2026");
+          const result = await spawnPluginCli("oc-codex-multi-account", [
+            "ping",
+            input.alias
+          ]);
+          const status = String(result.status ?? "error");
+          ctx.log("info", `Result: ${status}`);
+          if (status === "ok") {
+            await clearStaleMetrics(input.provider, input.alias);
+          }
+          return {
+            status,
+            message: status === "ok" ? "pong" : String(result.error ?? "unknown error")
+          };
+        }
+        case "antigravity": {
+          const creds = await readCredentialFile("antigravity-accounts.json");
+          const accounts = Array.isArray(creds.accounts) ? creds.accounts : [];
+          const account = accounts.find((a) => a.email === input.alias);
+          if (!account) {
+            throw new Error(`Account "${input.alias}" not found`);
+          }
+          if (!account.refreshToken) {
+            throw new Error(`No refresh token for "${input.alias}"`);
+          }
+          ctx.log("info", "Refresh token present");
+          await clearStaleMetrics(input.provider, input.alias);
+          return {
+            status: "ok",
+            message: "pong (credentials present)"
+          };
+        }
+        default:
+          throw new Error(`Unknown provider: ${input.provider}`);
+      }
+    }
+  });
+  REAUTH_PROVIDERS = {
+    anthropic: "oc-anthropic-multi-account",
+    codex: "oc-codex-multi-account"
+  };
+  registerCommand({
+    id: "accounts.reauth-start",
+    timeoutMs: 15000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("accounts.reauth-start requires a non-empty 'provider' string");
+      }
+      if (typeof p.alias !== "string" || !p.alias) {
+        throw new Error("accounts.reauth-start requires a non-empty 'alias' string");
+      }
+      return { provider: p.provider, alias: p.alias };
+    },
+    async run(ctx, input) {
+      const cliCmd = reauthCliCommand(input.provider);
+      ctx.log("info", `Generating auth URL for ${input.alias}\u2026`);
+      const result = await spawnPluginCli(cliCmd, ["reauth", input.alias]);
+      const url = String(result.url ?? "");
+      const verifier = String(result.verifier ?? "");
+      if (!url || !verifier) {
+        throw new Error("CLI did not return url/verifier");
+      }
+      ctx.log("info", "Auth URL generated");
+      return { url, verifier };
+    }
+  });
+  registerCommand({
+    id: "accounts.reauth-complete",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("accounts.reauth-complete requires 'provider'");
+      }
+      if (typeof p.alias !== "string" || !p.alias) {
+        throw new Error("accounts.reauth-complete requires 'alias'");
+      }
+      if (typeof p.callbackUrl !== "string" || !p.callbackUrl) {
+        throw new Error("accounts.reauth-complete requires 'callbackUrl'");
+      }
+      if (typeof p.verifier !== "string" || !p.verifier) {
+        throw new Error("accounts.reauth-complete requires 'verifier'");
+      }
+      return {
+        provider: p.provider,
+        alias: p.alias,
+        callbackUrl: p.callbackUrl,
+        verifier: p.verifier
+      };
+    },
+    async run(ctx, input) {
+      const cliCmd = reauthCliCommand(input.provider);
+      ctx.log("info", `Completing re-auth for ${input.alias}\u2026`);
+      const result = await spawnPluginCli(cliCmd, [
+        "reauth",
+        "--callback",
+        input.callbackUrl,
+        "--verifier",
+        input.verifier,
+        input.alias
+      ]);
+      const status = String(result.status ?? "error");
+      ctx.log("info", `Result: ${status}`);
+      return {
+        status,
+        message: status === "ok" ? "Re-authenticated successfully" : String(result.error ?? "unknown error")
+      };
+    }
+  });
+  registerCommand({
+    id: "actions.thresholds",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.provider !== "string" || !p.provider) {
+        throw new Error("actions.thresholds requires a non-empty 'provider' string");
+      }
+      if (typeof p.warning !== "number") {
+        throw new Error("actions.thresholds requires a numeric 'warning' value");
+      }
+      if (typeof p.critical !== "number") {
+        throw new Error("actions.thresholds requires a numeric 'critical' value");
+      }
+      return {
+        provider: p.provider,
+        warning: p.warning,
+        critical: p.critical
+      };
+    },
+    async run(ctx, input) {
+      const source = resolveSource2(input.provider);
+      ctx.log("info", `Updating thresholds for "${input.provider}" \u2014 warning: ${input.warning}, critical: ${input.critical}`);
+      const data = await readConfig(source);
+      data.thresholds = {
+        warning: input.warning,
+        critical: input.critical
+      };
+      await writeConfig(source, data);
+      ctx.log("info", "Thresholds updated successfully");
+      return { ok: true };
+    }
+  });
+  registerCommand({
+    id: "actions.import",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.source !== "string" || !p.source) {
+        throw new Error("actions.import requires a non-empty 'source' string");
+      }
+      if (p.data === undefined) {
+        throw new Error("actions.import requires a 'data' field");
+      }
+      return { source: p.source, data: p.data };
+    },
+    async run(ctx, input) {
+      ctx.log("info", `Importing config into "${input.source}"`);
+      const { backupPath } = await writeConfig(input.source, input.data);
+      ctx.log("info", `Config imported, backup at ${backupPath}`);
+      return { ok: true, backupPath };
+    }
+  });
+  registerCommand({
+    id: "actions.export",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.source !== "string" || !p.source) {
+        throw new Error("actions.export requires a non-empty 'source' string");
+      }
+      return { source: p.source };
+    },
+    async run(ctx, input) {
+      ctx.log("info", `Exporting config from "${input.source}"`);
+      const data = await readConfig(input.source);
+      ctx.log("info", "Config exported successfully");
+      return { source: input.source, data };
+    }
+  });
+  registerCommand({
+    id: "actions.reset",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.source !== "string" || !p.source) {
+        throw new Error("actions.reset requires a non-empty 'source' string");
+      }
+      return { source: p.source };
+    },
+    async run(ctx, input) {
+      ctx.log("info", `Resetting config "${input.source}" to empty object`);
+      const { backupPath } = await writeConfig(input.source, {});
+      ctx.log("info", `Config reset, backup at ${backupPath}`);
+      return { ok: true, backupPath };
+    }
+  });
+  registerCommand({
+    id: "actions.rollback",
+    timeoutMs: 30000,
+    allowInUi: true,
+    validateInput(payload) {
+      const p = payload;
+      if (!p || typeof p.source !== "string" || !p.source) {
+        throw new Error("actions.rollback requires a non-empty 'source' string");
+      }
+      return { source: p.source };
+    },
+    async run(ctx, input) {
+      ctx.log("info", `Rolling back config "${input.source}" to latest backup`);
+      const { restoredFrom } = await rollbackConfig(input.source);
+      ctx.log("info", `Config restored from ${restoredFrom}`);
+      return { ok: true, restoredFrom };
+    }
+  });
+});
 
 // src/cli.ts
 import { parseArgs as nodeParseArgs } from "util";
@@ -48,6 +797,8 @@ function parseArgs() {
         watch: { type: "boolean", short: "w" },
         stats: { type: "boolean", short: "S" },
         config: { type: "string" },
+        commander: { type: "boolean" },
+        "commander-port": { type: "string" },
         help: { type: "boolean", short: "h" }
       },
       strict: true
@@ -65,7 +816,9 @@ function parseArgs() {
       monthly: values.monthly,
       watch: values.watch,
       stats: values.stats,
-      config: values.config
+      config: values.config,
+      commander: values.commander,
+      commanderPort: values["commander-port"] ? parseInt(values["commander-port"], 10) : undefined
     };
   } catch (error) {
     if (error instanceof Error && error.message.includes("Unknown option")) {
@@ -86,6 +839,7 @@ Usage:
 Modes:
   (default)               Interactive dashboard (Bun only)
   -S, --stats             Stats table mode (works with Node.js too)
+  --commander             Start Commander web server (Bun only)
 
 Options:
   -p, --provider <name>   Filter by provider (anthropic, openai, google, opencode)
@@ -97,6 +851,7 @@ Options:
   -w, --watch             Watch mode - refresh every 5 minutes (stats mode only)
       --config show       Show current configuration
   -h, --help              Show this help message
+      --commander-port <n>  Commander server port (default: 3000)
 
 Codex Quota:
   Dashboard auto-reads Codex auth from ~/.codex/auth.json.
@@ -29386,6 +30141,573 @@ async function showConfig() {
 }
 var CODEX_AUTH_PATH2 = join6(homedir4(), ".codex", "auth.json");
 
+// src/commander/server.ts
+import { join as join10, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/commander/services/quota-service.ts
+async function getQuotaData() {
+  const [anthropic, antigravity, codex] = await Promise.all([
+    loadMultiAccountQuota(),
+    loadAntigravityQuota(),
+    loadCodexQuota()
+  ]);
+  return { anthropic, antigravity, codex };
+}
+
+// src/commander/server.ts
+init_command_runner();
+
+// src/commander/services/action-service.ts
+function ensureActionsRegistered() {
+  if (registered)
+    return;
+  registered = true;
+  Promise.resolve().then(() => init_plugin_adapters());
+}
+var isBun5 = typeof globalThis.Bun !== "undefined";
+var registered = false;
+
+// src/commander/services/app-init-service.ts
+init_command_runner();
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
+async function fileExists2(path2) {
+  try {
+    const file = Bun.file(path2);
+    return await file.exists();
+  } catch {
+    return false;
+  }
+}
+async function readOpencodeJson() {
+  try {
+    const file = Bun.file(OPENCODE_JSON_PATH);
+    if (!await file.exists())
+      return {};
+    const text = await file.text();
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+function pluginListContains(config, pluginName) {
+  const plugins = config.plugins;
+  if (!Array.isArray(plugins))
+    return false;
+  return plugins.some((p) => typeof p === "string" && p.includes(pluginName));
+}
+async function patchPluginList(pluginEntry) {
+  const config = await readOpencodeJson();
+  if (!Array.isArray(config.plugins)) {
+    config.plugins = [];
+  }
+  const plugins = config.plugins;
+  if (plugins.includes(pluginEntry))
+    return;
+  plugins.push(pluginEntry);
+  await Bun.write(OPENCODE_JSON_PATH, JSON.stringify(config, null, 2));
+}
+function spawnSyncCheck(cmd) {
+  try {
+    const result = Bun.spawnSync(cmd, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function spawnAndLog(ctx, cmd, options) {
+  ctx.log("info", `Running: ${cmd.join(" ")}`);
+  try {
+    const proc = Bun.spawn(cmd, {
+      cwd: options?.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    await proc.exited;
+    if (stdout.trim())
+      ctx.log("info", stdout.trim());
+    if (stderr.trim())
+      ctx.log("warn", stderr.trim());
+    return proc.exitCode === 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Spawn failed";
+    ctx.log("error", message);
+    return false;
+  }
+}
+async function detectOcCodexMultiAccount() {
+  const binaryPath = join9(OPENCODE_CONFIG_DIR, "node_modules", ".bin", "oc-codex-multi-account");
+  const binaryExists = await fileExists2(binaryPath);
+  const config = await readOpencodeJson();
+  const pluginConfigured = pluginListContains(config, "oc-codex-multi-account");
+  let state;
+  const details = [];
+  if (binaryExists && pluginConfigured) {
+    state = "ready";
+    details.push("Binary installed", "Plugin configured");
+  } else if (binaryExists || pluginConfigured) {
+    state = "partial";
+    if (!binaryExists)
+      details.push("Binary missing");
+    if (!pluginConfigured)
+      details.push("Plugin not configured");
+  } else {
+    state = "not-installed";
+    details.push("Binary not found", "Plugin not configured");
+  }
+  return {
+    id: "oc-codex-multi-account",
+    name: "OC Codex Multi-Account",
+    description: "Multi-account support for OpenAI Codex via OpenCode plugin",
+    state,
+    details
+  };
+}
+async function detectOcAnthropicMultiAccount() {
+  const dirPath = "/Users/gabrielecegi/oc/oc-anthropic-multi-account";
+  const statePath = join9(OPENCODE_CONFIG_DIR, "anthropic-multi-account-state.json");
+  const dirExists = await fileExists2(dirPath);
+  const stateExists = await fileExists2(statePath);
+  let state;
+  const details = [];
+  if (dirExists && stateExists) {
+    state = "ready";
+    details.push("Project directory found", "State file present");
+  } else if (dirExists) {
+    state = "partial";
+    details.push("Project directory found", "State file missing");
+  } else {
+    state = "not-installed";
+    details.push("Project directory not found");
+    if (!stateExists)
+      details.push("State file missing");
+  }
+  return {
+    id: "oc-anthropic-multi-account",
+    name: "OC Anthropic Multi-Account",
+    description: "Multi-account support for Anthropic via OpenCode plugin",
+    state,
+    details
+  };
+}
+async function detectOpencodeGitbutler() {
+  const butAvailable = spawnSyncCheck(["but", "--version"]);
+  const config = await readOpencodeJson();
+  const pluginConfigured = pluginListContains(config, "opencode-gitbutler");
+  let state;
+  const details = [];
+  if (butAvailable && pluginConfigured) {
+    state = "ready";
+    details.push("GitButler CLI available", "Plugin configured");
+  } else if (!butAvailable) {
+    state = "missing-deps";
+    details.push("GitButler CLI (but) not found");
+    if (!pluginConfigured)
+      details.push("Plugin not configured");
+  } else {
+    state = "partial";
+    details.push("GitButler CLI available", "Plugin not configured");
+  }
+  return {
+    id: "opencode-gitbutler",
+    name: "OpenCode GitButler",
+    description: "GitButler integration for OpenCode",
+    state,
+    details
+  };
+}
+async function detectOpencodeUsage() {
+  const available = spawnSyncCheck(["bunx", "opencode-usage", "--help"]);
+  let state;
+  const details = [];
+  if (available) {
+    state = "ready";
+    details.push("opencode-usage available via bunx");
+  } else {
+    state = "not-installed";
+    details.push("opencode-usage not available");
+  }
+  return {
+    id: "opencode-usage",
+    name: "OpenCode Usage",
+    description: "CLI tool for tracking OpenCode AI usage and costs",
+    state,
+    details
+  };
+}
+async function getAppCatalog() {
+  const results = await Promise.all([
+    detectOcCodexMultiAccount(),
+    detectOcAnthropicMultiAccount(),
+    detectOpencodeGitbutler(),
+    detectOpencodeUsage()
+  ]);
+  return results;
+}
+function validateAppInput(payload) {
+  if (typeof payload !== "object" || payload === null || !("appId" in payload)) {
+    throw new Error('Missing "appId" in payload');
+  }
+  const { appId } = payload;
+  if (typeof appId !== "string" || !VALID_APP_IDS.has(appId)) {
+    throw new Error(`Invalid appId: "${String(appId)}"`);
+  }
+  return { appId };
+}
+async function initOcCodexMultiAccount(ctx) {
+  await spawnAndLog(ctx, [
+    "bun",
+    "add",
+    "oc-codex-multi-account",
+    "--cwd",
+    OPENCODE_CONFIG_DIR
+  ]);
+  await patchPluginList("oc-codex-multi-account@latest");
+  ctx.log("info", "Plugin configured in opencode.json");
+  ctx.log("info", `To add accounts, run: ${join9(OPENCODE_CONFIG_DIR, "node_modules", ".bin", "oc-codex-multi-account")} add <alias>`);
+}
+async function initOcAnthropicMultiAccount(ctx) {
+  const dirPath = "/Users/gabrielecegi/oc/oc-anthropic-multi-account";
+  const dirExists = await fileExists2(dirPath);
+  if (!dirExists) {
+    ctx.log("error", `Project directory not found: ${dirPath}. Clone the repo first.`);
+    return;
+  }
+  await spawnAndLog(ctx, ["bun", "install"], { cwd: dirPath });
+  await patchPluginList("oc-anthropic-multi-account@latest");
+  ctx.log("info", "Plugin configured in opencode.json");
+  ctx.log("info", `To add accounts, run: cd ${dirPath} && bun src/cli.ts add primary`);
+}
+async function initOpencodeGitbutler(ctx) {
+  await patchPluginList("opencode-gitbutler@latest");
+  ctx.log("info", "Plugin configured in opencode.json");
+  ctx.log("info", "To install GitButler CLI, run: brew install gitbutler");
+}
+async function initOpencodeUsage(ctx) {
+  const ok = await spawnAndLog(ctx, ["bunx", "opencode-usage", "--help"]);
+  if (ok) {
+    ctx.log("info", "opencode-usage is working correctly");
+  }
+  ctx.log("info", "opencode-usage is available via bunx. For global install: bun add -g opencode-usage");
+}
+async function runInit(ctx, input) {
+  ctx.log("info", `Initializing app: ${input.appId}`);
+  switch (input.appId) {
+    case "oc-codex-multi-account":
+      await initOcCodexMultiAccount(ctx);
+      break;
+    case "oc-anthropic-multi-account":
+      await initOcAnthropicMultiAccount(ctx);
+      break;
+    case "opencode-gitbutler":
+      await initOpencodeGitbutler(ctx);
+      break;
+    case "opencode-usage":
+      await initOpencodeUsage(ctx);
+      break;
+  }
+  return { ok: true };
+}
+async function runRepair(ctx, input) {
+  ctx.log("info", `Repairing app: ${input.appId}`);
+  const catalog = await getAppCatalog();
+  const app = catalog.find((a) => a.id === input.appId);
+  if (!app) {
+    ctx.log("error", `App not found: ${input.appId}`);
+    return { ok: false, state: "not-installed" };
+  }
+  ctx.log("info", `Current state: ${app.state} \u2014 ${app.details.join(", ")}`);
+  if (app.state === "ready") {
+    ctx.log("info", "App is already in ready state, no repair needed");
+    return { ok: true, state: "ready" };
+  }
+  ctx.log("info", "Attempting repair via init workflow...");
+  await runInit(ctx, input);
+  const afterCatalog = await getAppCatalog();
+  const afterApp = afterCatalog.find((a) => a.id === input.appId);
+  const finalState = afterApp?.state ?? "not-installed";
+  ctx.log("info", `Post-repair state: ${finalState}`);
+  return { ok: finalState === "ready", state: finalState };
+}
+function ensureAppCommandsRegistered() {
+  if (registered2)
+    return;
+  registered2 = true;
+  registerCommand({
+    id: "apps.init",
+    validateInput: validateAppInput,
+    run: runInit,
+    timeoutMs: 120000,
+    allowInUi: true
+  });
+  registerCommand({
+    id: "apps.repair",
+    validateInput: validateAppInput,
+    run: runRepair,
+    timeoutMs: 120000,
+    allowInUi: true
+  });
+}
+var isBun6 = typeof globalThis.Bun !== "undefined";
+var OPENCODE_CONFIG_DIR = join9(homedir7(), ".config", "opencode");
+var OPENCODE_JSON_PATH = join9(OPENCODE_CONFIG_DIR, "opencode.json");
+var VALID_APP_IDS = new Set([
+  "oc-codex-multi-account",
+  "oc-anthropic-multi-account",
+  "opencode-gitbutler",
+  "opencode-usage"
+]);
+var registered2 = false;
+
+// src/commander/server.ts
+init_config_service();
+function queryUsageInWorker(opts) {
+  return new Promise((resolve3, reject) => {
+    const worker = new Worker(usageWorkerPath);
+    worker.onmessage = (event) => {
+      worker.terminate();
+      const msg = event.data;
+      if (msg.ok)
+        resolve3(msg.data);
+      else
+        reject(new Error(msg.error));
+    };
+    worker.onerror = (err) => {
+      worker.terminate();
+      reject(err);
+    };
+    worker.postMessage(opts);
+  });
+}
+async function runCommanderServer(args) {
+  if (!isBun7) {
+    console.error("Commander mode requires Bun runtime.");
+    process.exit(1);
+  }
+  ensureActionsRegistered();
+  ensureAppCommandsRegistered();
+  await listConfigFiles();
+  const port = args.commanderPort ?? DEFAULT_PORT;
+  const hostname = "127.0.0.1";
+  Bun.serve({
+    hostname,
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (req.method === "GET" && url.pathname === "/api/health") {
+        return Response.json({
+          status: "ok",
+          version: PKG_VERSION,
+          timestamp: new Date().toISOString()
+        });
+      }
+      if (req.method === "GET" && url.pathname === "/api/usage") {
+        try {
+          const provider = url.searchParams.get("provider") ?? undefined;
+          const daysParam = url.searchParams.get("days");
+          const days = daysParam !== null ? Number(daysParam) : undefined;
+          const since = url.searchParams.get("since") ?? undefined;
+          const until = url.searchParams.get("until") ?? undefined;
+          const monthly = url.searchParams.get("monthly") === "true";
+          const data = await queryUsageInWorker({
+            provider,
+            days,
+            since,
+            until,
+            monthly
+          });
+          return Response.json(data);
+        } catch (err) {
+          return Response.json({
+            error: err instanceof Error ? err.message : "Internal server error"
+          }, { status: 500 });
+        }
+      }
+      if (req.method === "GET" && url.pathname === "/api/quota") {
+        try {
+          const data = await getQuotaData();
+          return Response.json(data);
+        } catch (err) {
+          return Response.json({
+            error: err instanceof Error ? err.message : "Internal server error"
+          }, { status: 500 });
+        }
+      }
+      if (req.method === "POST" && url.pathname === "/api/commands/run") {
+        try {
+          const body = await req.json();
+          if (typeof body.commandId !== "string" || !body.commandId) {
+            return Response.json({ error: "Missing or invalid commandId" }, { status: 400 });
+          }
+          const jobId = runCommand(body.commandId, body.payload);
+          return Response.json({ jobId }, { status: 202 });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      }
+      if (req.method === "GET" && url.pathname.startsWith("/api/jobs/")) {
+        const jobId = url.pathname.slice("/api/jobs/".length);
+        const job = getJob(jobId);
+        if (!job) {
+          return Response.json({ error: "Not found" }, { status: 404 });
+        }
+        return Response.json(job);
+      }
+      if (req.method === "GET" && url.pathname === "/api/config/files") {
+        try {
+          const files = await listConfigFiles();
+          return Response.json(files);
+        } catch (err) {
+          return Response.json({
+            error: err instanceof Error ? err.message : "Internal server error"
+          }, { status: 500 });
+        }
+      }
+      if (req.method === "GET" && url.pathname.startsWith("/api/config/") && url.pathname !== "/api/config/files") {
+        const source = url.pathname.slice("/api/config/".length);
+        if (!isValidSource(source)) {
+          return Response.json({ error: `Unknown config source: ${source}` }, { status: 404 });
+        }
+        try {
+          const data = readConfig(source);
+          return Response.json(data);
+        } catch (err) {
+          const status = err instanceof ConfigError ? err.status : 500;
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status });
+        }
+      }
+      if (req.method === "PUT" && url.pathname.startsWith("/api/config/")) {
+        const source = url.pathname.slice("/api/config/".length);
+        if (!isValidSource(source)) {
+          return Response.json({ error: `Unknown config source: ${source}` }, { status: 404 });
+        }
+        try {
+          const body = await req.json();
+          const { backupPath } = await writeConfig(source, body);
+          return Response.json({ ok: true, backupPath });
+        } catch (err) {
+          if (err instanceof SyntaxError) {
+            return Response.json({ error: "Request body is not valid JSON" }, { status: 400 });
+          }
+          const status = err instanceof ConfigError ? err.status : 500;
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status });
+        }
+      }
+      if (req.method === "POST" && url.pathname.endsWith("/rollback") && url.pathname.startsWith("/api/config/")) {
+        const source = url.pathname.slice("/api/config/".length).replace(/\/rollback$/, "");
+        if (!isValidSource(source)) {
+          return Response.json({ error: `Unknown config source: ${source}` }, { status: 404 });
+        }
+        try {
+          const result = await rollbackConfig(source);
+          return Response.json({ ok: true, ...result });
+        } catch (err) {
+          const status = err instanceof ConfigError ? err.status : 500;
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status });
+        }
+      }
+      if (req.method === "POST" && url.pathname.startsWith("/api/accounts/")) {
+        const parts = url.pathname.split("/");
+        const provider = parts[3];
+        const action = parts[4];
+        if (!provider || !action) {
+          return Response.json({ error: "Invalid account route" }, { status: 400 });
+        }
+        try {
+          const body = await req.json();
+          const jobId = runCommand(`accounts.${action}`, {
+            provider,
+            ...body
+          });
+          return Response.json({ jobId }, { status: 202 });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      }
+      if (req.method === "POST" && url.pathname.startsWith("/api/actions/")) {
+        const action = url.pathname.slice("/api/actions/".length);
+        if (!action) {
+          return Response.json({ error: "Invalid action route" }, { status: 400 });
+        }
+        try {
+          const body = await req.json();
+          const jobId = runCommand(`actions.${action}`, body);
+          return Response.json({ jobId }, { status: 202 });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      }
+      if (req.method === "GET" && url.pathname === "/api/apps") {
+        try {
+          const catalog = await getAppCatalog();
+          return Response.json(catalog);
+        } catch (err) {
+          return Response.json({
+            error: err instanceof Error ? err.message : "Internal server error"
+          }, { status: 500 });
+        }
+      }
+      if (req.method === "POST" && url.pathname.startsWith("/api/apps/") && url.pathname.endsWith("/init")) {
+        const appId = url.pathname.slice("/api/apps/".length).replace(/\/init$/, "");
+        try {
+          const jobId = runCommand("apps.init", { appId });
+          return Response.json({ jobId }, { status: 202 });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      }
+      if (req.method === "POST" && url.pathname.startsWith("/api/apps/") && url.pathname.endsWith("/repair")) {
+        const appId = url.pathname.slice("/api/apps/".length).replace(/\/repair$/, "");
+        try {
+          const jobId = runCommand("apps.repair", { appId });
+          return Response.json({ jobId }, { status: 202 });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      }
+      if (!url.pathname.startsWith("/api/")) {
+        const UI_DIST = join10(new URL(".", import.meta.url).pathname, "../commander-ui/dist");
+        const filePath = url.pathname === "/" ? join10(UI_DIST, "index.html") : join10(UI_DIST, url.pathname);
+        const file = Bun.file(filePath);
+        if (await file.exists())
+          return new Response(file);
+        return new Response(Bun.file(join10(UI_DIST, "index.html")));
+      }
+      return Response.json({ error: "Not found" }, { status: 404 });
+    }
+  });
+  const serverUrl = `http://${hostname}:${port}`;
+  console.log(`Commander ready at ${serverUrl}`);
+  if (isBun7 && !process.env.NO_OPEN) {
+    const cmd = process.platform === "win32" ? ["cmd", "/c", "start", serverUrl] : process.platform === "darwin" ? ["open", serverUrl] : ["xdg-open", serverUrl];
+    Bun.spawn(cmd, { stdio: ["ignore", "ignore", "ignore"] });
+  }
+}
+var isBun7 = typeof globalThis.Bun !== "undefined";
+var DEFAULT_PORT = 4466;
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var PKG_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(readFileSync2(join10(__dirname2, "..", "..", "package.json"), "utf-8"));
+    return String(pkg.version ?? "0.0.0");
+  } catch {
+    return "0.0.0";
+  }
+})();
+var usageWorkerPath = join10(__dirname2, "services", "usage-worker.ts");
 // src/index.ts
 function clearScreen() {
   process.stdout.write("\x1B[2J\x1B[H");
@@ -29435,7 +30757,23 @@ async function renderUsage(options, allMessages) {
   }
 }
 async function main2() {
-  const { provider, days, since, until, json, monthly, watch, stats, config } = parseArgs();
+  const args = parseArgs();
+  const {
+    provider,
+    days,
+    since,
+    until,
+    json,
+    monthly,
+    watch,
+    stats,
+    config,
+    commander
+  } = args;
+  if (commander) {
+    await runCommanderServer(args);
+    return;
+  }
   if (config === "show") {
     await showConfig();
     return;
@@ -29480,4 +30818,4 @@ async function main2() {
 var WATCH_INTERVAL_MS = 5 * 60 * 1000;
 main2().catch(console.error);
 
-//# debugId=41CAA4E4B5E2848664756E2164756E21
+//# debugId=FEF96600978E6E5764756E2164756E21