@wbern/cc-ping 0.1.0

package/dist/cli.js

@@ -0,0 +1,1584 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/paths.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+function setConfigDir(dir) {
+  configDirOverride = dir;
+}
+function resolveConfigDir() {
+  if (configDirOverride) return configDirOverride;
+  if (process.env.CC_PING_CONFIG) return process.env.CC_PING_CONFIG;
+  return join2(homedir(), ".config", "cc-ping");
+}
+var configDirOverride;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  addAccount: () => addAccount,
+  listAccounts: () => listAccounts,
+  loadConfig: () => loadConfig,
+  removeAccount: () => removeAccount,
+  saveConfig: () => saveConfig
+});
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
+function loadConfig() {
+  const configFile = join3(resolveConfigDir(), "config.json");
+  if (!existsSync2(configFile)) {
+    return { accounts: [] };
+  }
+  try {
+    const raw = readFileSync2(configFile, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { accounts: [] };
+  }
+}
+function saveConfig(config) {
+  const configDir = resolveConfigDir();
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(
+    join3(configDir, "config.json"),
+    `${JSON.stringify(config, null, 2)}
+`
+  );
+}
+function addAccount(handle, configDir, group) {
+  const config = loadConfig();
+  const existing = config.accounts.findIndex((a) => a.handle === handle);
+  if (existing !== -1) {
+    config.accounts[existing].configDir = configDir;
+    config.accounts[existing].group = group;
+  } else {
+    const account = { handle, configDir };
+    if (group) account.group = group;
+    config.accounts.push(account);
+  }
+  saveConfig(config);
+}
+function removeAccount(handle) {
+  const config = loadConfig();
+  const before = config.accounts.length;
+  config.accounts = config.accounts.filter((a) => a.handle !== handle);
+  if (config.accounts.length === before) return false;
+  saveConfig(config);
+  return true;
+}
+function listAccounts() {
+  return loadConfig().accounts;
+}
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/state.ts
+var state_exports = {};
+__export(state_exports, {
+  QUOTA_WINDOW_MS: () => QUOTA_WINDOW_MS,
+  formatTimeRemaining: () => formatTimeRemaining,
+  getLastPing: () => getLastPing,
+  getLastPingMeta: () => getLastPingMeta,
+  getWindowReset: () => getWindowReset,
+  loadState: () => loadState,
+  recordPing: () => recordPing,
+  saveState: () => saveState
+});
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+function loadState() {
+  const stateFile = join4(resolveConfigDir(), "state.json");
+  if (!existsSync3(stateFile)) {
+    return { lastPing: {} };
+  }
+  try {
+    const raw = readFileSync3(stateFile, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { lastPing: {} };
+  }
+}
+function saveState(state) {
+  const configDir = resolveConfigDir();
+  mkdirSync2(configDir, { recursive: true });
+  writeFileSync2(
+    join4(configDir, "state.json"),
+    `${JSON.stringify(state, null, 2)}
+`
+  );
+}
+function recordPing(handle, timestamp = /* @__PURE__ */ new Date(), meta) {
+  const state = loadState();
+  state.lastPing[handle] = timestamp.toISOString();
+  if (meta) {
+    if (!state.lastPingMeta) state.lastPingMeta = {};
+    state.lastPingMeta[handle] = meta;
+  }
+  saveState(state);
+}
+function getLastPingMeta(handle) {
+  const state = loadState();
+  return state.lastPingMeta?.[handle] ?? null;
+}
+function getLastPing(handle) {
+  const state = loadState();
+  const iso = state.lastPing[handle];
+  if (!iso) return null;
+  return new Date(iso);
+}
+function getWindowReset(handle, now = /* @__PURE__ */ new Date()) {
+  const lastPing = getLastPing(handle);
+  if (!lastPing) return null;
+  const resetAt = new Date(lastPing.getTime() + QUOTA_WINDOW_MS);
+  const remainingMs = resetAt.getTime() - now.getTime();
+  if (remainingMs <= 0) return null;
+  if (remainingMs > QUOTA_WINDOW_MS) return null;
+  return { resetAt, remainingMs };
+}
+function formatTimeRemaining(ms) {
+  if (ms <= 0) return "expired";
+  const totalMinutes = Math.ceil(ms / 6e4);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+var QUOTA_WINDOW_MS;
+var init_state = __esm({
+  "src/state.ts"() {
+    "use strict";
+    init_paths();
+    QUOTA_WINDOW_MS = 5 * 60 * 60 * 1e3;
+  }
+});
+
+// src/bell.ts
+function ringBell(write) {
+  const w = write ?? ((s) => process.stdout.write(s));
+  w("\x07");
+}
+var init_bell = __esm({
+  "src/bell.ts"() {
+    "use strict";
+  }
+});
+
+// src/history.ts
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+function historyFile() {
+  return join5(resolveConfigDir(), "history.jsonl");
+}
+function appendHistoryEntry(entry) {
+  const dir = resolveConfigDir();
+  mkdirSync3(dir, { recursive: true });
+  appendFileSync(historyFile(), `${JSON.stringify(entry)}
+`);
+}
+function formatHistoryEntry(entry) {
+  const status = entry.success ? "ok" : "FAIL";
+  const error = entry.error ? ` (${entry.error})` : "";
+  return `  ${entry.timestamp}  ${entry.handle}: ${status} ${entry.durationMs}ms${error}`;
+}
+function readHistory(limit) {
+  const file = historyFile();
+  if (!existsSync4(file)) return [];
+  const content = readFileSync4(file, "utf-8").trim();
+  if (!content) return [];
+  const entries = content.split("\n").map((line) => JSON.parse(line));
+  if (limit !== void 0 && limit < entries.length) {
+    return entries.slice(-limit);
+  }
+  return entries;
+}
+var init_history = __esm({
+  "src/history.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/logger.ts
+function createLogger(options) {
+  const stdout = options.stdout ?? console.log;
+  const stderr = options.stderr ?? console.error;
+  return {
+    log: (msg) => {
+      if (!options.quiet) {
+        stdout(msg);
+      }
+    },
+    error: (msg) => {
+      stderr(msg);
+    }
+  };
+}
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+  }
+});
+
+// src/notify.ts
+import { execFile as defaultExecFile } from "child_process";
+function buildNotifyCommand(title, body, platform, options) {
+  switch (platform) {
+    case "darwin": {
+      let script = `display notification "${body}" with title "${title}"`;
+      if (options?.sound) script += ` sound name "default"`;
+      return ["osascript", ["-e", script]];
+    }
+    case "linux":
+      return ["notify-send", [title, body]];
+    case "win32":
+      return [
+        "powershell",
+        [
+          "-Command",
+          `[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); $n = New-Object System.Windows.Forms.NotifyIcon; $n.Icon = [System.Drawing.SystemIcons]::Information; $n.Visible = $true; $n.ShowBalloonTip(5000, '${title}', '${body}', 'Error'); Start-Sleep -Seconds 6; $n.Dispose()`
+        ]
+      ];
+    default:
+      return null;
+  }
+}
+function sendNotification(title, body, opts) {
+  const platform = opts?.platform ?? process.platform;
+  const exec = opts?.exec ?? defaultExecFile;
+  const cmd = buildNotifyCommand(title, body, platform, { sound: opts?.sound });
+  if (!cmd) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    exec(cmd[0], cmd[1], (error) => {
+      resolve(!error);
+    });
+  });
+}
+var init_notify = __esm({
+  "src/notify.ts"() {
+    "use strict";
+  }
+});
+
+// src/parse.ts
+function parseClaudeResponse(stdout) {
+  if (!stdout) return null;
+  let raw;
+  try {
+    raw = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (raw.type !== "result") return null;
+  if (!raw.usage || typeof raw.usage !== "object") return null;
+  const usage = raw.usage;
+  const modelUsage = raw.modelUsage ?? raw.model_usage;
+  const model = modelUsage ? Object.keys(modelUsage)[0] ?? "unknown" : "unknown";
+  return {
+    type: raw.type,
+    subtype: raw.subtype ?? "",
+    session_id: raw.session_id ?? "",
+    duration_ms: raw.duration_ms ?? 0,
+    duration_api_ms: raw.duration_api_ms ?? 0,
+    is_error: raw.is_error ?? false,
+    num_turns: raw.num_turns ?? 0,
+    result: raw.result ?? "",
+    total_cost_usd: raw.total_cost_usd ?? 0,
+    usage: {
+      input_tokens: usage.input_tokens ?? 0,
+      output_tokens: usage.output_tokens ?? 0,
+      cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+      cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0
+    },
+    model
+  };
+}
+var init_parse = __esm({
+  "src/parse.ts"() {
+    "use strict";
+  }
+});
+
+// src/prompt.ts
+function rand(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function generatePrompt() {
+  const op = OPERATIONS[Math.floor(Math.random() * OPERATIONS.length)];
+  const [a, b] = op.gen();
+  const expr = `${a} ${op.symbol} ${b}`;
+  const template = TEMPLATES[Math.floor(Math.random() * TEMPLATES.length)];
+  return template(expr);
+}
+var TEMPLATES, OPERATIONS;
+var init_prompt = __esm({
+  "src/prompt.ts"() {
+    "use strict";
+    TEMPLATES = [
+      (expr) => `Quick, take a guess: what is ${expr}?`,
+      (expr) => `Without thinking too hard, what's ${expr}?`,
+      (expr) => `Off the top of your head: ${expr} = ?`,
+      (expr) => `Just guess, no need to be exact: ${expr}?`,
+      (expr) => `Rough estimate: what does ${expr} equal?`
+    ];
+    OPERATIONS = [
+      { symbol: "+", gen: () => [rand(100, 9999), rand(100, 9999)] },
+      { symbol: "-", gen: () => [rand(500, 9999), rand(100, 4999)] },
+      { symbol: "*", gen: () => [rand(10, 999), rand(10, 999)] },
+      { symbol: "/", gen: () => [rand(100, 9999), rand(2, 99)] }
+    ];
+  }
+});
+
+// src/ping.ts
+import { execFile } from "child_process";
+function formatExecError(error) {
+  if ("killed" in error && error.killed) {
+    return "timed out";
+  }
+  const msg = error.message;
+  if (msg.startsWith("Command failed:")) {
+    return "command failed";
+  }
+  return msg;
+}
+function pingOne(account) {
+  const start = Date.now();
+  return new Promise((resolve) => {
+    const child = execFile(
+      "claude",
+      [
+        "-p",
+        generatePrompt(),
+        "--output-format",
+        "json",
+        "--tools",
+        "",
+        "--max-turns",
+        "1"
+      ],
+      {
+        env: { ...process.env, CLAUDE_CONFIG_DIR: account.configDir },
+        timeout: 3e4
+      },
+      (error, stdout) => {
+        const claudeResponse = parseClaudeResponse(stdout) ?? void 0;
+        const isError = claudeResponse?.is_error === true;
+        let errorMsg;
+        if (error) {
+          if (isError && claudeResponse?.subtype) {
+            errorMsg = claudeResponse.subtype;
+          } else {
+            errorMsg = formatExecError(error);
+          }
+        } else if (isError) {
+          errorMsg = claudeResponse?.subtype;
+        }
+        resolve({
+          handle: account.handle,
+          success: !error && !isError,
+          durationMs: Date.now() - start,
+          error: errorMsg,
+          claudeResponse
+        });
+      }
+    );
+    child.stdin?.end();
+  });
+}
+async function pingAccounts(accounts, options = {}) {
+  if (options.parallel) {
+    return Promise.all(accounts.map(pingOne));
+  }
+  const results = [];
+  for (const account of accounts) {
+    results.push(await pingOne(account));
+  }
+  return results;
+}
+var init_ping = __esm({
+  "src/ping.ts"() {
+    "use strict";
+    init_parse();
+    init_prompt();
+  }
+});
+
+// src/run-ping.ts
+var run_ping_exports = {};
+__export(run_ping_exports, {
+  runPing: () => runPing
+});
+async function runPing(accounts, options) {
+  const stdout = options.stdout ?? console.log;
+  const logger = createLogger({
+    quiet: options.quiet || options.json === true,
+    stdout,
+    stderr: options.stderr
+  });
+  const hadNoWindow = /* @__PURE__ */ new Set();
+  for (const a of accounts) {
+    if (!getWindowReset(a.handle)) {
+      hadNoWindow.add(a.handle);
+    }
+  }
+  logger.log(`Pinging ${accounts.length} account(s)...`);
+  const sleep = options._sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let results;
+  if (options.staggerMs && options.staggerMs > 0 && accounts.length > 1) {
+    results = [];
+    for (let i = 0; i < accounts.length; i++) {
+      if (i > 0) {
+        const minutes = Math.round(options.staggerMs / 6e4);
+        logger.log(`  waiting ${minutes}m before next ping...`);
+        await sleep(options.staggerMs);
+      }
+      const [result] = await pingAccounts([accounts[i]], {});
+      results.push(result);
+    }
+  } else {
+    results = await pingAccounts(accounts, {
+      parallel: options.parallel
+    });
+  }
+  for (const r of results) {
+    const status = r.success ? "ok" : "FAIL";
+    const detail = r.error ? ` (${r.error})` : "";
+    const cr = r.claudeResponse;
+    const costInfo = cr ? `  $${cr.total_cost_usd.toFixed(4)} ${cr.usage.input_tokens + cr.usage.output_tokens} tok` : "";
+    logger.log(
+      `  ${r.handle}: ${status} ${r.durationMs}ms${detail}${costInfo}`
+    );
+    appendHistoryEntry({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      handle: r.handle,
+      success: r.success,
+      durationMs: r.durationMs,
+      error: r.error
+    });
+    if (r.success) {
+      let meta;
+      if (cr) {
+        meta = {
+          costUsd: cr.total_cost_usd,
+          inputTokens: cr.usage.input_tokens,
+          outputTokens: cr.usage.output_tokens,
+          model: cr.model,
+          sessionId: cr.session_id
+        };
+      }
+      recordPing(r.handle, /* @__PURE__ */ new Date(), meta);
+    }
+  }
+  const failed = results.filter((r) => !r.success).length;
+  if (failed > 0 && options.bell) {
+    ringBell();
+  }
+  if (failed > 0 && options.notify) {
+    const failedHandles = results.filter((r) => !r.success).map((r) => r.handle);
+    await sendNotification(
+      "cc-ping: ping failure",
+      `${failed} account(s) failed: ${failedHandles.join(", ")}`
+    );
+  }
+  if (options.notify) {
+    const newWindows = results.filter((r) => r.success && hadNoWindow.has(r.handle)).map((r) => r.handle);
+    if (newWindows.length > 0) {
+      let body = `${newWindows.length} account(s) ready: ${newWindows.join(", ")}`;
+      if (options.wakeDelayMs) {
+        body += ` (woke ${formatTimeRemaining(options.wakeDelayMs)} late)`;
+      }
+      await sendNotification("cc-ping: new window", body, { sound: true });
+    }
+  }
+  if (options.json) {
+    const jsonResults = results.map((r) => ({
+      handle: r.handle,
+      success: r.success,
+      durationMs: r.durationMs,
+      error: r.error
+    }));
+    stdout(JSON.stringify(jsonResults, null, 2));
+    return failed > 0 ? 1 : 0;
+  }
+  if (failed > 0) {
+    logger.error(`${failed}/${results.length} failed`);
+    return 1;
+  }
+  logger.log(`
+All ${results.length} accounts pinged successfully`);
+  logger.log("\nWindow resets:");
+  for (const r of results) {
+    const window = getWindowReset(r.handle);
+    if (window) {
+      logger.log(
+        `  ${r.handle}: resets in ${formatTimeRemaining(window.remainingMs)}`
+      );
+    }
+  }
+  return 0;
+}
+var init_run_ping = __esm({
+  "src/run-ping.ts"() {
+    "use strict";
+    init_bell();
+    init_history();
+    init_logger();
+    init_notify();
+    init_ping();
+    init_state();
+  }
+});
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/check.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+function checkAccount(account) {
+  const issues = [];
+  if (!existsSync(account.configDir) || !statSync(account.configDir).isDirectory()) {
+    issues.push("config directory does not exist");
+    return {
+      handle: account.handle,
+      configDir: account.configDir,
+      healthy: false,
+      issues
+    };
+  }
+  const claudeJson = join(account.configDir, ".claude.json");
+  if (!existsSync(claudeJson)) {
+    issues.push(".claude.json not found");
+    return {
+      handle: account.handle,
+      configDir: account.configDir,
+      healthy: false,
+      issues
+    };
+  }
+  let parsed;
+  try {
+    const raw = readFileSync(claudeJson, "utf-8");
+    parsed = JSON.parse(raw);
+  } catch {
+    issues.push(".claude.json is not valid JSON");
+    return {
+      handle: account.handle,
+      configDir: account.configDir,
+      healthy: false,
+      issues
+    };
+  }
+  if (!parsed.oauthAccount) {
+    issues.push("no OAuth credentials found");
+  }
+  return {
+    handle: account.handle,
+    configDir: account.configDir,
+    healthy: issues.length === 0,
+    issues
+  };
+}
+function checkAccounts(accounts) {
+  return accounts.map((a) => checkAccount(a));
+}
+
+// src/completions.ts
+var COMMANDS = "ping scan add remove list status next-reset history suggest check completions moo daemon";
+function bashCompletion() {
+  return `_cc_ping() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${COMMANDS}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+    return 0
+  fi
+
+  case "\${COMP_WORDS[1]}" in
+    ping)
+      if [[ "\${cur}" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--parallel --quiet --json --group --bell --stagger" -- "\${cur}") )
+      else
+        local handles=$(cc-ping list 2>/dev/null | sed 's/ *\\(.*\\) ->.*/\\1/')
+        COMPREPLY=( $(compgen -W "\${handles}" -- "\${cur}") )
+      fi
+      ;;
+    add)
+      COMPREPLY=( $(compgen -W "--group" -- "\${cur}") )
+      ;;
+    list|history|status|next-reset|check)
+      COMPREPLY=( $(compgen -W "--json" -- "\${cur}") )
+      ;;
+    completions)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "\${cur}") )
+      ;;
+    daemon)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "start stop status" -- "\${cur}") )
+      elif [[ "\${COMP_WORDS[2]}" == "start" && "\${cur}" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--interval --quiet --bell --notify" -- "\${cur}") )
+      elif [[ "\${COMP_WORDS[2]}" == "status" && "\${cur}" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--json" -- "\${cur}") )
+      fi
+      ;;
+  esac
+  return 0
+}
+complete -F _cc_ping cc-ping
+`;
+}
+function zshCompletion() {
+  return `#compdef cc-ping
+
+_cc_ping() {
+  local -a commands
+  commands=(
+    'ping:Ping configured accounts'
+    'scan:Auto-discover accounts'
+    'add:Add an account manually'
+    'remove:Remove an account'
+    'list:List configured accounts'
+    'status:Show account status'
+    'next-reset:Show soonest quota reset'
+    'history:Show ping history'
+    'suggest:Suggest next account'
+    'check:Verify account health'
+    'completions:Generate shell completions'
+    'moo:Send a test notification'
+    'daemon:Run auto-ping on a schedule'
+  )
+
+  _arguments -C \\
+    '--config[Config directory]:path:_files -/' \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case $state in
+    command)
+      _describe 'command' commands
+      ;;
+    args)
+      case $words[1] in
+        ping)
+          _arguments \\
+            '--parallel[Ping in parallel]' \\
+            '--quiet[Suppress output]' \\
+            '--json[JSON output]' \\
+            '--group[Filter by group]:group:' \\
+            '--bell[Ring bell on failure]' \\
+            '--stagger[Delay between pings]:minutes:' \\
+            '*:handle:->handles'
+          if [[ $state == handles ]]; then
+            local -a handles
+            handles=(\${(f)"$(cc-ping list 2>/dev/null | sed 's/ *\\(.*\\) ->.*/\\1/')"})
+            _describe 'handle' handles
+          fi
+          ;;
+        completions)
+          _arguments '1:shell:(bash zsh fish)'
+          ;;
+        list|history|status|next-reset|check)
+          _arguments '--json[JSON output]'
+          ;;
+        add)
+          _arguments '--group[Assign group]:group:'
+          ;;
+        daemon)
+          local -a subcmds
+          subcmds=(
+            'start:Start the daemon process'
+            'stop:Stop the daemon process'
+            'status:Show daemon status'
+          )
+          _arguments '1:subcommand:->subcmd' '*::arg:->subargs'
+          case $state in
+            subcmd)
+              _describe 'subcommand' subcmds
+              ;;
+            subargs)
+              case $words[1] in
+                start)
+                  _arguments \\
+                    '--interval[Ping interval in minutes]:minutes:' \\
+                    '--quiet[Suppress ping output]' \\
+                    '--bell[Ring bell on failure]' \\
+                    '--notify[Send notification on failure]'
+                  ;;
+                status)
+                  _arguments '--json[JSON output]'
+                  ;;
+              esac
+              ;;
+          esac
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_cc_ping
+`;
+}
+function fishCompletion() {
+  return `# Fish completions for cc-ping
+set -l commands ping scan add remove list status next-reset history suggest check completions moo
+
+complete -c cc-ping -f
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a ping -d "Ping configured accounts"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a scan -d "Auto-discover accounts"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a add -d "Add an account manually"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a remove -d "Remove an account"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a list -d "List configured accounts"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a status -d "Show account status"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a next-reset -d "Show soonest quota reset"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a history -d "Show ping history"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a suggest -d "Suggest next account"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a check -d "Verify account health"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a completions -d "Generate shell completions"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a moo -d "Send a test notification"
+complete -c cc-ping -n "not __fish_seen_subcommand_from $commands" -a daemon -d "Run auto-ping on a schedule"
+
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -l parallel -d "Ping in parallel"
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -s q -l quiet -d "Suppress output"
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -l json -d "JSON output"
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -s g -l group -r -d "Filter by group"
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -l bell -d "Ring bell on failure"
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -l stagger -r -d "Delay between pings"
+complete -c cc-ping -n "__fish_seen_subcommand_from ping" -a "(cc-ping list 2>/dev/null | string replace -r ' *(.*) ->.*' '$1')"
+
+complete -c cc-ping -n "__fish_seen_subcommand_from list history status next-reset check" -l json -d "JSON output"
+complete -c cc-ping -n "__fish_seen_subcommand_from add" -s g -l group -r -d "Assign group"
+complete -c cc-ping -n "__fish_seen_subcommand_from completions" -a "bash zsh fish"
+
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and not __fish_seen_subcommand_from start stop status" -a start -d "Start the daemon"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and not __fish_seen_subcommand_from start stop status" -a stop -d "Stop the daemon"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and not __fish_seen_subcommand_from start stop status" -a status -d "Show daemon status"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and __fish_seen_subcommand_from start" -l interval -r -d "Ping interval in minutes"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and __fish_seen_subcommand_from start" -s q -l quiet -d "Suppress output"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and __fish_seen_subcommand_from start" -l bell -d "Ring bell on failure"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and __fish_seen_subcommand_from start" -l notify -d "Send notification on failure"
+complete -c cc-ping -n "__fish_seen_subcommand_from daemon; and __fish_seen_subcommand_from status" -l json -d "JSON output"
+`;
+}
+function generateCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return bashCompletion();
+    case "zsh":
+      return zshCompletion();
+    case "fish":
+      return fishCompletion();
+    default:
+      throw new Error(
+        `Unsupported shell: ${shell}. Supported: bash, zsh, fish`
+      );
+  }
+}
+
+// src/cli.ts
+init_config();
+
+// src/daemon.ts
+init_paths();
+init_state();
+import { execSync, spawn } from "child_process";
+import {
+  existsSync as existsSync5,
+  closeSync as fsCloseSync,
+  openSync as fsOpenSync,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join6 } from "path";
+var GRACEFUL_POLL_MS = 500;
+var GRACEFUL_POLL_ATTEMPTS = 20;
+var POST_KILL_DELAY_MS = 1e3;
+function daemonPidPath() {
+  return join6(resolveConfigDir(), "daemon.json");
+}
+function daemonLogPath() {
+  return join6(resolveConfigDir(), "daemon.log");
+}
+function daemonStopPath() {
+  return join6(resolveConfigDir(), "daemon.stop");
+}
+function writeDaemonState(state) {
+  const configDir = resolveConfigDir();
+  mkdirSync4(configDir, { recursive: true });
+  writeFileSync3(daemonPidPath(), `${JSON.stringify(state, null, 2)}
+`);
+}
+function readDaemonState() {
+  const pidPath = daemonPidPath();
+  if (!existsSync5(pidPath)) return null;
+  try {
+    const raw = readFileSync5(pidPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function removeDaemonState() {
+  const pidPath = daemonPidPath();
+  if (!existsSync5(pidPath)) return false;
+  unlinkSync(pidPath);
+  return true;
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+function isDaemonProcess(pid) {
+  try {
+    const output = execSync(`ps -p ${pid} -o command=`, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return output.includes("cc-ping");
+  } catch {
+    return false;
+  }
+}
+function parseInterval(value) {
+  if (!value) return QUOTA_WINDOW_MS;
+  const minutes = Number(value);
+  if (Number.isNaN(minutes)) {
+    throw new Error(`Invalid interval value: ${value}`);
+  }
+  if (minutes <= 0) {
+    throw new Error("Interval must be a positive number");
+  }
+  return minutes * 60 * 1e3;
+}
+function getDaemonStatus(deps) {
+  const _isDaemonProcess = deps?.isDaemonProcess ?? isDaemonProcess;
+  const state = readDaemonState();
+  if (!state) return { running: false };
+  if (!isProcessRunning(state.pid) || !_isDaemonProcess(state.pid)) {
+    removeDaemonState();
+    return { running: false };
+  }
+  const startedAt = new Date(state.startedAt);
+  const uptimeMs = Date.now() - startedAt.getTime();
+  const uptime = formatUptime(uptimeMs);
+  let nextPingIn;
+  if (state.lastPingAt) {
+    const nextPingMs = new Date(state.lastPingAt).getTime() + state.intervalMs - Date.now();
+    nextPingIn = formatUptime(Math.max(0, nextPingMs));
+  }
+  return {
+    running: true,
+    pid: state.pid,
+    startedAt: state.startedAt,
+    intervalMs: state.intervalMs,
+    uptime,
+    nextPingIn
+  };
+}
+function formatUptime(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+async function daemonLoop(intervalMs, options, deps) {
+  let wakeDelayMs;
+  while (!deps.shouldStop()) {
+    const allAccounts = deps.listAccounts();
+    const accounts = deps.isWindowActive ? allAccounts.filter((a) => !deps.isWindowActive(a.handle)) : allAccounts;
+    const skipped = allAccounts.length - accounts.length;
+    if (skipped > 0) {
+      deps.log(`Skipping ${skipped} account(s) with active window`);
+    }
+    if (accounts.length === 0) {
+      deps.log(
+        allAccounts.length === 0 ? "No accounts configured, waiting..." : "All accounts have active windows, waiting..."
+      );
+    } else {
+      deps.log(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] Pinging ${accounts.length} account(s)...`
+      );
+      await deps.runPing(accounts, {
+        parallel: false,
+        quiet: options.quiet ?? true,
+        bell: options.bell,
+        notify: options.notify,
+        wakeDelayMs
+      });
+      deps.updateState?.({ lastPingAt: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+    if (deps.shouldStop()) break;
+    deps.log(`Sleeping ${Math.round(intervalMs / 6e4)}m until next ping...`);
+    const sleepStart = Date.now();
+    await deps.sleep(intervalMs);
+    const overshootMs = Date.now() - sleepStart - intervalMs;
+    if (overshootMs > 6e4) {
+      wakeDelayMs = overshootMs;
+      deps.log(`Woke ${formatUptime(overshootMs)} late (system sleep?)`);
+    } else {
+      wakeDelayMs = void 0;
+    }
+  }
+}
+function startDaemon(options, deps) {
+  const _getDaemonStatus = deps?.getDaemonStatus ?? getDaemonStatus;
+  const _spawn = deps?.spawn ?? spawn;
+  const _writeDaemonState = deps?.writeDaemonState ?? writeDaemonState;
+  const _openSync = deps?.openSync ?? fsOpenSync;
+  const _closeSync = deps?.closeSync ?? fsCloseSync;
+  const status = _getDaemonStatus();
+  if (status.running) {
+    return {
+      success: false,
+      pid: status.pid,
+      error: "Daemon is already running"
+    };
+  }
+  let intervalMs;
+  try {
+    intervalMs = parseInterval(options.interval);
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+  const configDir = resolveConfigDir();
+  mkdirSync4(configDir, { recursive: true });
+  const logPath = daemonLogPath();
+  const logFd = _openSync(logPath, "a");
+  const args = ["daemon", "_run", "--interval-ms", String(intervalMs)];
+  if (options.quiet) args.push("--quiet");
+  if (options.bell) args.push("--bell");
+  if (options.notify) args.push("--notify");
+  const child = _spawn(process.execPath, [process.argv[1], ...args], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    windowsHide: true
+  });
+  if (!child.pid) {
+    _closeSync(logFd);
+    return { success: false, error: "Failed to spawn daemon process" };
+  }
+  child.unref();
+  _closeSync(logFd);
+  _writeDaemonState({
+    pid: child.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    intervalMs,
+    configDir
+  });
+  return { success: true, pid: child.pid };
+}
+async function stopDaemon(deps) {
+  const _getDaemonStatus = deps?.getDaemonStatus ?? getDaemonStatus;
+  const _writeStopFile = deps?.writeStopFile ?? /* c8 ignore next 5 -- production default */
+  (() => {
+    const configDir = resolveConfigDir();
+    mkdirSync4(configDir, { recursive: true });
+    writeFileSync3(daemonStopPath(), "");
+  });
+  const _isProcessRunning = deps?.isProcessRunning ?? isProcessRunning;
+  const _removeDaemonState = deps?.removeDaemonState ?? removeDaemonState;
+  const _removeStopFile = deps?.removeStopFile ?? /* c8 ignore next 4 -- production default */
+  (() => {
+    const stopPath = daemonStopPath();
+    if (existsSync5(stopPath)) unlinkSync(stopPath);
+  });
+  const _sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const _kill = deps?.kill ?? /* c8 ignore next 7 -- production default */
+  ((pid2) => {
+    if (process.platform === "win32") {
+      execSync(`taskkill /PID ${pid2}`);
+    } else {
+      process.kill(pid2, "SIGTERM");
+    }
+  });
+  const status = _getDaemonStatus();
+  if (!status.running || !status.pid) {
+    return { success: false, error: "Daemon is not running" };
+  }
+  const pid = status.pid;
+  _writeStopFile();
+  for (let i = 0; i < GRACEFUL_POLL_ATTEMPTS; i++) {
+    await _sleep(GRACEFUL_POLL_MS);
+    if (!_isProcessRunning(pid)) {
+      _removeDaemonState();
+      _removeStopFile();
+      return { success: true, pid };
+    }
+  }
+  try {
+    _kill(pid);
+  } catch {
+  }
+  await _sleep(POST_KILL_DELAY_MS);
+  _removeDaemonState();
+  _removeStopFile();
+  return { success: true, pid };
+}
+async function runDaemon(intervalMs, options, deps) {
+  const stopPath = daemonStopPath();
+  const cleanup = () => {
+    if (existsSync5(stopPath)) unlinkSync(stopPath);
+    removeDaemonState();
+  };
+  const onSigterm = () => {
+    deps.log("Received SIGTERM, shutting down...");
+    cleanup();
+    deps.exit(0);
+  };
+  const onSigint = () => {
+    deps.log("Received SIGINT, shutting down...");
+    cleanup();
+    deps.exit(0);
+  };
+  deps.onSignal("SIGTERM", onSigterm);
+  deps.onSignal("SIGINT", onSigint);
+  deps.log(`Daemon started. Interval: ${Math.round(intervalMs / 6e4)}m`);
+  try {
+    await daemonLoop(intervalMs, options, deps);
+  } finally {
+    deps.removeSignal("SIGTERM", onSigterm);
+    deps.removeSignal("SIGINT", onSigint);
+    deps.log("Daemon stopping...");
+    cleanup();
+  }
+}
+async function runDaemonWithDefaults(intervalMs, options) {
+  const stopPath = daemonStopPath();
+  const { runPing: runPing2 } = await Promise.resolve().then(() => (init_run_ping(), run_ping_exports));
+  const { listAccounts: listAccounts2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { getWindowReset: getWindowReset2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  await runDaemon(intervalMs, options, {
+    runPing: runPing2,
+    listAccounts: listAccounts2,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    shouldStop: () => existsSync5(stopPath),
+    log: (msg) => console.log(msg),
+    isWindowActive: (handle) => getWindowReset2(handle) !== null,
+    updateState: (patch) => {
+      const current = readDaemonState();
+      if (current) writeDaemonState({ ...current, ...patch });
+    },
+    onSignal: (signal, handler) => process.on(signal, handler),
+    removeSignal: (signal, handler) => process.removeListener(signal, handler),
+    exit: (code) => process.exit(code)
+  });
+}
+
+// src/filter-accounts.ts
+function filterAccounts(accounts, handles) {
+  if (handles.length === 0) return accounts;
+  const unknown = handles.filter((h) => !accounts.some((a) => a.handle === h));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown account(s): ${unknown.join(", ")}`);
+  }
+  const set = new Set(handles);
+  return accounts.filter((a) => set.has(a.handle));
+}
+function filterByGroup(accounts, group) {
+  if (!group) return accounts;
+  const filtered = accounts.filter((a) => a.group === group);
+  if (filtered.length === 0) {
+    throw new Error(`No accounts in group: ${group}`);
+  }
+  return filtered;
+}
+
+// src/cli.ts
+init_history();
+
+// src/identity.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+function readAccountIdentity(configDir) {
+  let raw;
+  try {
+    raw = readFileSync6(join7(configDir, ".claude.json"), "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const oauth = parsed.oauthAccount;
+  if (!oauth) return null;
+  const accountUuid = oauth.accountUuid;
+  const email = oauth.emailAddress;
+  if (typeof accountUuid !== "string" || typeof email !== "string") return null;
+  return { accountUuid, email };
+}
+function findDuplicates(accounts) {
+  const byUuid = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    const identity = readAccountIdentity(account.configDir);
+    if (!identity) continue;
+    const existing = byUuid.get(identity.accountUuid);
+    if (existing) {
+      existing.handles.push(account.handle);
+    } else {
+      byUuid.set(identity.accountUuid, {
+        handles: [account.handle],
+        email: identity.email
+      });
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [uuid, group] of byUuid) {
+    if (group.handles.length >= 2) {
+      result.set(uuid, group);
+    }
+  }
+  return result;
+}
+
+// src/next-reset.ts
+init_state();
+function getNextReset(accounts, now = /* @__PURE__ */ new Date()) {
+  let best = null;
+  for (const account of accounts) {
+    const window = getWindowReset(account.handle, now);
+    if (!window) continue;
+    if (best === null || window.remainingMs < best.remainingMs) {
+      best = {
+        handle: account.handle,
+        configDir: account.configDir,
+        remainingMs: window.remainingMs,
+        resetAt: window.resetAt.toISOString(),
+        timeUntilReset: formatTimeRemaining(window.remainingMs)
+      };
+    }
+  }
+  return best;
+}
+
+// src/cli.ts
+init_notify();
+init_paths();
+init_run_ping();
+
+// src/scan.ts
+import { existsSync as existsSync6, readdirSync, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+var ACCOUNTS_DIR = join8(homedir2(), ".claude-accounts");
+function scanAccounts() {
+  if (!existsSync6(ACCOUNTS_DIR)) return [];
+  return readdirSync(ACCOUNTS_DIR).filter((name) => {
+    const full = join8(ACCOUNTS_DIR, name);
+    return statSync2(full).isDirectory() && !name.startsWith(".");
+  }).map((name) => ({
+    handle: name,
+    configDir: join8(ACCOUNTS_DIR, name)
+  }));
+}
+
+// src/stagger.ts
+init_state();
+function calculateStagger(accountCount, windowMs = QUOTA_WINDOW_MS) {
+  if (accountCount <= 1) return 0;
+  return Math.floor(windowMs / accountCount);
+}
+function parseStagger(value, accountCount) {
+  if (value === "auto") {
+    return calculateStagger(accountCount);
+  }
+  const minutes = Number(value);
+  if (Number.isNaN(minutes)) {
+    throw new Error(`Invalid stagger value: ${value}`);
+  }
+  if (minutes <= 0) {
+    throw new Error("Stagger must be a positive number");
+  }
+  return minutes * 60 * 1e3;
+}
+
+// src/status.ts
+init_config();
+init_state();
+function formatStatusLine(status) {
+  const ping = status.lastPing === null ? "never" : status.lastPing.replace("T", " ").replace(/\.\d+Z$/, "Z");
+  const reset = status.timeUntilReset !== null ? ` (resets in ${status.timeUntilReset})` : "";
+  const cost = status.lastCostUsd !== null && status.lastTokens !== null ? `  $${status.lastCostUsd.toFixed(4)} ${status.lastTokens} tok` : "";
+  const dup = status.duplicateOf ? `  [duplicate of ${status.duplicateOf}]` : "";
+  return `  ${status.handle}: ${status.windowStatus}  last ping: ${ping}${reset}${cost}${dup}`;
+}
+function getAccountStatuses(accounts, now = /* @__PURE__ */ new Date(), duplicates) {
+  const dupLookup = /* @__PURE__ */ new Map();
+  if (duplicates) {
+    for (const group of duplicates.values()) {
+      for (const handle of group.handles) {
+        const others = group.handles.filter((h) => h !== handle).join(", ");
+        if (others) dupLookup.set(handle, others);
+      }
+    }
+  }
+  return accounts.map((account) => {
+    const lastPing = getLastPing(account.handle);
+    const meta = getLastPingMeta(account.handle);
+    const lastCostUsd = meta?.costUsd ?? null;
+    const lastTokens = meta !== null ? meta.inputTokens + meta.outputTokens : null;
+    const duplicateOf = dupLookup.get(account.handle);
+    if (!lastPing) {
+      return {
+        handle: account.handle,
+        configDir: account.configDir,
+        lastPing: null,
+        windowStatus: "unknown",
+        timeUntilReset: null,
+        lastCostUsd,
+        lastTokens,
+        duplicateOf
+      };
+    }
+    const window = getWindowReset(account.handle, now);
+    return {
+      handle: account.handle,
+      configDir: account.configDir,
+      lastPing: lastPing.toISOString(),
+      windowStatus: window ? "active" : "expired",
+      timeUntilReset: window ? formatTimeRemaining(window.remainingMs) : null,
+      lastCostUsd,
+      lastTokens,
+      duplicateOf
+    };
+  });
+}
+function printAccountTable(log = console.log, now = /* @__PURE__ */ new Date()) {
+  const accounts = listAccounts();
+  if (accounts.length === 0) {
+    log("No accounts configured");
+    return;
+  }
+  const dupes = findDuplicates(accounts);
+  const statuses = getAccountStatuses(accounts, now, dupes);
+  for (const s of statuses) {
+    log(formatStatusLine(s));
+  }
+}
+
+// src/suggest.ts
+init_state();
+function suggestAccount(accounts, now = /* @__PURE__ */ new Date()) {
+  if (accounts.length === 0) return null;
+  for (const account of accounts) {
+    const window = getWindowReset(account.handle, now);
+    if (!window) {
+      return {
+        handle: account.handle,
+        configDir: account.configDir,
+        reason: "no active window",
+        timeUntilReset: null
+      };
+    }
+  }
+  let best = null;
+  for (const account of accounts) {
+    const window = getWindowReset(account.handle, now);
+    if (window && (best === null || window.remainingMs > best.remainingMs)) {
+      best = { account, remainingMs: window.remainingMs };
+    }
+  }
+  return {
+    handle: best.account.handle,
+    configDir: best.account.configDir,
+    reason: "most remaining window time",
+    timeUntilReset: formatTimeRemaining(best.remainingMs)
+  };
+}
+
+// src/cli.ts
+var program = new Command().name("cc-ping").description("Ping Claude Code sessions to trigger quota windows early").version("0.1.0").option(
+  "--config <path>",
+  "Path to config directory (default: ~/.config/cc-ping, env: CC_PING_CONFIG)"
+).hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.config) {
+    setConfigDir(opts.config);
+  }
+});
+program.command("ping").description("Ping configured accounts to start quota windows").argument("[handles...]", "Specific account handles to ping (default: all)").option("--parallel", "Ping all accounts in parallel", false).option("-q, --quiet", "Suppress all output except errors (for cron)", false).option("--json", "Output results as JSON", false).option("-g, --group <group>", "Ping only accounts in this group").option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).option(
+  "--stagger <minutes|auto>",
+  "Delay between account pings (minutes or 'auto')"
+).action(async (handles, opts) => {
+  const accounts = listAccounts();
+  if (accounts.length === 0) {
+    console.error(
+      "No accounts configured. Run: cc-ping scan or cc-ping add <handle> <dir>"
+    );
+    process.exit(1);
+  }
+  const targets = filterAccounts(
+    filterByGroup(accounts, opts.group),
+    handles
+  );
+  const staggerMs = opts.stagger ? parseStagger(opts.stagger, targets.length) : void 0;
+  const exitCode = await runPing(targets, {
+    parallel: opts.parallel,
+    quiet: opts.quiet,
+    json: opts.json,
+    bell: opts.bell,
+    notify: opts.notify,
+    staggerMs
+  });
+  process.exit(exitCode);
+});
+program.command("check").description(
+  "Verify account config directories are valid and have credentials"
+).option("--json", "Output as JSON", false).action((opts) => {
+  const accounts = listAccounts();
+  if (accounts.length === 0) {
+    console.log("No accounts configured");
+    return;
+  }
+  const results = checkAccounts(accounts);
+  if (opts.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  for (const r of results) {
+    const status = r.healthy ? "healthy" : "UNHEALTHY";
+    const issues = r.issues.length > 0 ? ` (${r.issues.join("; ")})` : "";
+    console.log(`  ${r.handle}: ${status}${issues}`);
+  }
+  const unhealthy = results.filter((r) => !r.healthy).length;
+  if (unhealthy > 0) {
+    process.exit(1);
+  }
+});
+program.command("scan").description("Auto-discover accounts from ~/.claude-accounts/").option("--dry-run", "Show what would be added without saving", false).action((opts) => {
+  const found = scanAccounts();
+  if (found.length === 0) {
+    console.log("No accounts found in ~/.claude-accounts/");
+    return;
+  }
+  console.log(`Found ${found.length} account(s):`);
+  for (const a of found) {
+    console.log(`  ${a.handle} -> ${a.configDir}`);
+  }
+  if (!opts.dryRun) {
+    saveConfig({ accounts: found });
+    console.log("\nSaved to config.");
+  }
+  const dupes = findDuplicates(found);
+  if (dupes.size > 0) {
+    console.log(
+      "\nWarning: duplicate accounts detected (same underlying identity):"
+    );
+    for (const group of dupes.values()) {
+      console.log(`  ${group.handles.join(", ")} (${group.email})`);
+    }
+  }
+});
+program.command("add").description("Add an account manually").argument("<handle>", "Account handle/name").argument("<config-dir>", "Path to the CLAUDE_CONFIG_DIR for this account").option("-g, --group <group>", "Assign account to a group").action((handle, configDir, opts) => {
+  addAccount(handle, configDir, opts.group);
+  const groupInfo = opts.group ? ` [${opts.group}]` : "";
+  console.log(`Added: ${handle} -> ${configDir}${groupInfo}`);
+});
+program.command("remove").description("Remove an account").argument("<handle>", "Account handle to remove").action((handle) => {
+  if (removeAccount(handle)) {
+    console.log(`Removed: ${handle}`);
+  } else {
+    console.error(`Account not found: ${handle}`);
+    process.exit(1);
+  }
+});
+program.command("list").description("List configured accounts").option("--json", "Output as JSON", false).action((opts) => {
+  const accounts = listAccounts();
+  if (accounts.length === 0) {
+    console.log(opts.json ? "[]" : "No accounts configured");
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(accounts, null, 2));
+    return;
+  }
+  for (const a of accounts) {
+    console.log(`  ${a.handle} -> ${a.configDir}`);
+  }
+});
+program.command("status").description("Show status of all accounts with window information").option("--json", "Output as JSON", false).action((opts) => {
+  if (opts.json) {
+    const accounts = listAccounts();
+    const dupes = findDuplicates(accounts);
+    const statuses = getAccountStatuses(accounts, /* @__PURE__ */ new Date(), dupes);
+    console.log(JSON.stringify(statuses, null, 2));
+    return;
+  }
+  printAccountTable();
+});
+program.command("next-reset").description("Show which account has its quota window resetting soonest").option("--json", "Output as JSON", false).action((opts) => {
+  const accounts = listAccounts();
+  if (accounts.length === 0) {
+    console.log(opts.json ? "null" : "No accounts configured");
+    return;
+  }
+  const result = getNextReset(accounts);
+  if (opts.json) {
+    console.log(JSON.stringify(result ?? null, null, 2));
+    return;
+  }
+  if (!result) {
+    console.log("No active quota windows");
+    return;
+  }
+  console.log(
+    `${result.handle}: resets in ${result.timeUntilReset} (${result.configDir})`
+  );
+});
+program.command("suggest").description("Suggest which account to use next based on quota window state").option("--json", "Output as JSON", false).action((opts) => {
+  const accounts = listAccounts();
+  if (accounts.length === 0) {
+    console.log(opts.json ? "null" : "No accounts configured");
+    return;
+  }
+  const result = suggestAccount(accounts);
+  if (opts.json) {
+    console.log(JSON.stringify(result ?? null, null, 2));
+    return;
+  }
+  if (!result) {
+    console.log("No accounts configured");
+    return;
+  }
+  const resetInfo = result.timeUntilReset ? `, resets in ${result.timeUntilReset}` : "";
+  console.log(
+    `${result.handle} (${result.reason}${resetInfo}) -> ${result.configDir}`
+  );
+});
+program.command("history").description("Show recent ping history").option("--limit <n>", "Number of entries to show", "20").option("--json", "Output as JSON", false).action((opts) => {
+  const limit = Number.parseInt(opts.limit, 10);
+  const entries = readHistory(limit);
+  if (entries.length === 0) {
+    console.log(opts.json ? "[]" : "No ping history");
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  for (const entry of entries) {
+    console.log(formatHistoryEntry(entry));
+  }
+});
+program.command("completions").description("Generate shell completion script").argument("<shell>", "Shell type: bash, zsh, or fish").action((shell) => {
+  console.log(generateCompletion(shell));
+});
+program.command("moo").description("Send a test notification to verify desktop notifications work").action(async () => {
+  const ok = await sendNotification(
+    "cc-ping",
+    "Moo! Notifications are working."
+  );
+  if (ok) {
+    console.log("Notification sent");
+  } else {
+    console.error(
+      "Notification failed (unsupported platform or command error)"
+    );
+    process.exit(1);
+  }
+});
+var daemon = program.command("daemon").description("Run auto-ping on a schedule");
+daemon.command("start").description("Start the daemon process").option(
+  "--interval <minutes>",
+  "Ping interval in minutes (default: 300 = 5h quota window)"
+).option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).action((opts) => {
+  const result = startDaemon({
+    interval: opts.interval,
+    quiet: opts.quiet,
+    bell: opts.bell,
+    notify: opts.notify
+  });
+  if (!result.success) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Daemon started (PID: ${result.pid})`);
+  printAccountTable();
+});
+daemon.command("stop").description("Stop the daemon process").action(async () => {
+  const result = await stopDaemon();
+  if (!result.success) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Daemon stopped (PID: ${result.pid})`);
+});
+daemon.command("status").description("Show daemon status").option("--json", "Output as JSON", false).action((opts) => {
+  const status = getDaemonStatus();
+  if (opts.json) {
+    if (!status.running) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    const accounts = listAccounts();
+    const dupes = findDuplicates(accounts);
+    const accountStatuses = getAccountStatuses(accounts, /* @__PURE__ */ new Date(), dupes);
+    console.log(
+      JSON.stringify({ ...status, accounts: accountStatuses }, null, 2)
+    );
+    return;
+  }
+  if (!status.running) {
+    console.log("Daemon is not running");
+    return;
+  }
+  console.log(`Daemon is running (PID: ${status.pid})`);
+  console.log(`  Started: ${status.startedAt}`);
+  console.log(
+    `  Interval: ${Math.round((status.intervalMs ?? 0) / 6e4)}m`
+  );
+  console.log(`  Uptime: ${status.uptime}`);
+  if (status.nextPingIn) {
+    console.log(`  Next ping in: ${status.nextPingIn}`);
+  }
+  console.log("");
+  printAccountTable();
+});
+daemon.command("_run", { hidden: true }).option("--interval-ms <ms>", "Ping interval in milliseconds").option("-q, --quiet", "Suppress ping output", false).option("--bell", "Ring terminal bell on ping failure", false).option("--notify", "Send desktop notification on ping failure", false).action(async (opts) => {
+  const intervalMs = Number(opts.intervalMs);
+  if (!intervalMs || intervalMs <= 0) {
+    console.error("Invalid --interval-ms");
+    process.exit(1);
+  }
+  await runDaemonWithDefaults(intervalMs, {
+    quiet: opts.quiet,
+    bell: opts.bell,
+    notify: opts.notify
+  });
+});
+program.parse();