claude-code-discord-status 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+<p align="center">
+  <img src="./assets/hero-banner.svg" alt="claude-code-discord-status" width="900" />
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/claude-code-discord-status"><img src="https://img.shields.io/npm/v/claude-code-discord-status?color=5865f2&style=flat-square" alt="npm version" /></a>
+  <a href="https://github.com/BrunoJurkovic/claude-code-discord-status/actions"><img src="https://img.shields.io/github/actions/workflow/status/BrunoJurkovic/claude-code-discord-status/ci.yml?style=flat-square" alt="CI" /></a>
+  <a href="https://github.com/BrunoJurkovic/claude-code-discord-status/blob/main/LICENSE"><img src="https://img.shields.io/github/license/BrunoJurkovic/claude-code-discord-status?style=flat-square" alt="License" /></a>
+  <img src="https://img.shields.io/node/v/claude-code-discord-status?style=flat-square" alt="Node version" />
+</p>
+
+<p align="center">
+  Show what Claude Code is doing as a live Discord Rich Presence card.<br/>
+  Hooks into Claude Code's lifecycle events and updates your Discord status in real time.
+</p>
+
+---
+
+## Preview
+
+<p align="center">
+  <img src="./assets/card-single.svg" alt="Single session card" width="340" />
+  &nbsp;&nbsp;
+  <img src="./assets/card-multi.svg" alt="Multi-session card" width="340" />
+</p>
+
+<p align="center">
+  <b>Single session</b> — shows current action + project name &nbsp;·&nbsp; <b>Multiple sessions</b> — quirky messages + aggregate stats
+</p>
+
+## Features
+
+- **Live activity updates** — Your Discord card reflects what Claude is doing right now (editing, searching, running commands, thinking)
+- **MCP-powered custom messages** — Claude can set its own status via `set_discord_status`, with a 30-second priority window over hook updates
+- **Multi-session support** — Running multiple Claude Code instances? The card escalates with quirky messages and aggregated stats
+- **Activity mode detection** — Dominant activity type (coding, terminal, searching, thinking) changes the card icon
+- **Rotating tooltips** — Hidden easter eggs on hover, rotating every 5 minutes
+- **Auto-reconnect** — Daemon handles Discord RPC disconnects gracefully
+
+## Quick Start
+
+### Prerequisites
+
+- Node.js >= 18
+- [jq](https://jqlang.github.io/jq/) (`brew install jq` / `apt install jq`)
+- Discord desktop app running
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI installed
+
+### Setup
+
+```bash
+npx claude-code-discord-status setup
+```
+
+This will:
+
+1. Create a config at `~/.claude-discord-status/config.json`
+2. Register the MCP server with Claude Code
+3. Add lifecycle hooks to `~/.claude/settings.json`
+4. Start the daemon in the background
+
+That's it. Your Discord status updates automatically whenever you use Claude Code.
+
+## How It Works
+
+<p align="center">
+  <img src="./assets/architecture.svg" alt="Architecture diagram" width="800" />
+</p>
+
+Three components work together:
+
+1. **Hooks** — Bash scripts fired by Claude Code lifecycle events (session start/end, tool use, prompt submit). They POST updates to the daemon's HTTP API.
+2. **MCP Server** — An MCP tool (`set_discord_status`) that Claude can call to set a custom, contextual status message — these take priority for 30 seconds.
+3. **Daemon** — Background process that holds the Discord RPC connection, tracks all sessions, resolves what to show, and pushes it to Discord.
+
+> See [docs/architecture.md](./docs/architecture.md) for the full deep dive.
+
+## CLI
+
+```bash
+npx claude-code-discord-status setup          # Interactive setup wizard
+npx claude-code-discord-status status         # Check daemon status and active sessions
+npx claude-code-discord-status start -d       # Start daemon in background
+npx claude-code-discord-status stop           # Stop the daemon
+npx claude-code-discord-status uninstall      # Remove everything
+```
+
+## Configuration
+
+Config file: `~/.claude-discord-status/config.json`
+
+| Key | Env Override | Default | Description |
+| --- | --- | --- | --- |
+| `discordClientId` | `CLAUDE_DISCORD_CLIENT_ID` | `1472915568930848829` | Discord Application Client ID |
+| `daemonPort` | `CLAUDE_DISCORD_PORT` | `19452` | Local HTTP server port |
+
+The default client ID works out of the box — it's a public app identifier, not a secret.
+
+> See [docs/setup.md](./docs/setup.md) for all config options, timeouts, and how to use a custom Discord application.
+
+## Multi-Session Fun
+
+When you're running multiple Claude Code sessions, the card gets quirky:
+
+- **2 sessions** — _"Dual-wielding codebases"_, _"Pair programming with myself"_
+- **3 sessions** — _"Triple threat detected"_, _"Three-ring circus"_
+- **4 sessions** — _"4 parallel universes deep"_, _"One for each brain cell"_
+- **5+ sessions** — _"Send help (5 projects)"_, _"Gone feral (6 projects)"_
+
+Plus aggregate stats like `23 edits · 8 cmds · 2h 15m deep` and rotating hover tooltips like _"Technically I'm one Claude in a trenchcoat"_.
+
+> See [docs/multi-session.md](./docs/multi-session.md) for the full message pool and how the resolver works.
+
+## Development
+
+```bash
+git clone https://github.com/BrunoJurkovic/claude-code-discord-status.git
+cd claude-code-discord-status
+npm install
+npm run build
+npm test
+```
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,505 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { spawn, execSync } from "child_process";
+import { join as join2, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import * as p from "@clack/prompts";
+
+// src/shared/constants.ts
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_PORT = 19452;
+var CONFIG_DIR = join(homedir(), ".claude-discord-status");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var PID_FILE = join(CONFIG_DIR, "daemon.pid");
+var LOG_FILE = join(CONFIG_DIR, "daemon.log");
+var DEFAULT_DISCORD_CLIENT_ID = "1472915568930848829";
+var STALE_CHECK_INTERVAL = 3e4;
+var IDLE_TIMEOUT = 6e5;
+var REMOVE_TIMEOUT = 18e5;
+
+// src/shared/config.ts
+import { readFileSync, existsSync } from "fs";
+function loadConfig() {
+  let fileConfig = {};
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      const raw = readFileSync(CONFIG_FILE, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {
+    }
+  }
+  return {
+    discordClientId: process.env.CLAUDE_DISCORD_CLIENT_ID ?? fileConfig.discordClientId ?? DEFAULT_DISCORD_CLIENT_ID,
+    daemonPort: process.env.CLAUDE_DISCORD_PORT ? parseInt(process.env.CLAUDE_DISCORD_PORT, 10) : fileConfig.daemonPort ?? DEFAULT_PORT,
+    staleCheckInterval: fileConfig.staleCheckInterval ?? STALE_CHECK_INTERVAL,
+    idleTimeout: fileConfig.idleTimeout ?? IDLE_TIMEOUT,
+    removeTimeout: fileConfig.removeTimeout ?? REMOVE_TIMEOUT
+  };
+}
+
+// src/cli-utils.ts
+var green = (s) => `\x1B[32m${s}\x1B[39m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[39m`;
+var dim = (s) => `\x1B[2m${s}\x1B[22m`;
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+function statusBadge(status) {
+  if (status === "active") return green("active");
+  if (status === "idle") return yellow("idle");
+  return dim(status);
+}
+function connectionBadge(connected) {
+  return connected ? green("Connected") : yellow("Connecting...");
+}
+
+// src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var args = process.argv.slice(2);
+var command = args[0];
+function getDaemonPid() {
+  try {
+    if (existsSync2(PID_FILE)) {
+      const pid = parseInt(readFileSync2(PID_FILE, "utf-8").trim(), 10);
+      process.kill(pid, 0);
+      return pid;
+    }
+  } catch {
+    try {
+      unlinkSync(PID_FILE);
+    } catch {
+    }
+  }
+  return null;
+}
+async function checkHealth() {
+  const config = loadConfig();
+  try {
+    const res = await fetch(`http://127.0.0.1:${config.daemonPort}/health`);
+    if (res.ok) {
+      return await res.json();
+    }
+  } catch {
+  }
+  return null;
+}
+async function startDaemon(background) {
+  p.intro("claude-discord-status");
+  const existing = getDaemonPid();
+  if (existing) {
+    p.log.warn(`Daemon is already running (PID ${existing})`);
+    p.outro();
+    return;
+  }
+  const daemonPath = resolve(__dirname, "daemon", "index.js");
+  if (!existsSync2(daemonPath)) {
+    p.log.error(`Daemon entry point not found at ${daemonPath}`);
+    p.log.info("Run `npm run build` first.");
+    p.outro();
+    process.exit(1);
+  }
+  if (background) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    const { openSync } = await import("fs");
+    const logFd = openSync(LOG_FILE, "a");
+    const child = spawn("node", [daemonPath], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env }
+    });
+    child.unref();
+    p.log.success(`Daemon started in background (PID ${child.pid})`);
+    p.log.info(`Log file: ${LOG_FILE}`);
+    p.outro();
+  } else {
+    p.log.info("Starting daemon in foreground...");
+    p.outro();
+    const child = spawn("node", [daemonPath], {
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+  }
+}
+async function stopDaemon() {
+  p.intro("claude-discord-status");
+  const pid = getDaemonPid();
+  if (!pid) {
+    p.log.info("Daemon is not running.");
+    p.outro();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    p.log.success(`Daemon stopped (PID ${pid})`);
+  } catch {
+    p.log.info("Daemon process not found, cleaning up PID file.");
+  }
+  try {
+    unlinkSync(PID_FILE);
+  } catch {
+  }
+  p.outro();
+}
+async function showStatus() {
+  p.intro("claude-discord-status");
+  const pid = getDaemonPid();
+  const health = await checkHealth();
+  if (!pid && !health) {
+    p.log.info("Daemon is not running.");
+    p.outro();
+    return;
+  }
+  const lines = [];
+  lines.push(`PID        ${pid ?? "unknown"}`);
+  if (health) {
+    lines.push(`Discord    ${connectionBadge(health.connected)}`);
+    lines.push(`Sessions   ${health.sessions} active`);
+    lines.push(`Uptime     ${formatDuration(health.uptime * 1e3)}`);
+  } else {
+    lines.push(`Health     Could not reach daemon`);
+  }
+  p.note(lines.join("\n"), "Daemon Status");
+  const config = loadConfig();
+  try {
+    const res = await fetch(`http://127.0.0.1:${config.daemonPort}/sessions`);
+    if (res.ok) {
+      const sessions = await res.json();
+      if (sessions.length > 0) {
+        for (const s of sessions) {
+          const elapsed = s.startedAt ? formatDuration(Date.now() - new Date(s.startedAt).getTime()) : "";
+          const badge = statusBadge(s.status);
+          p.log.step(`${s.projectName}
+  ${s.details} \u2014 ${badge}${elapsed ? ` \u2014 ${elapsed}` : ""}`);
+        }
+      }
+    }
+  } catch {
+  }
+  p.outro();
+}
+async function setup() {
+  p.intro("claude-discord-status");
+  const nodeVersion = process.versions.node;
+  const nodeMajor = parseInt(nodeVersion.split(".")[0], 10);
+  if (nodeMajor < 18) {
+    p.log.error(`Node.js >= 18 required (found ${nodeVersion})`);
+    p.outro();
+    process.exit(1);
+  }
+  let jqVersion = "";
+  try {
+    jqVersion = execSync("jq --version", { stdio: "pipe" }).toString().trim();
+  } catch {
+    p.log.error("jq is required but not found.");
+    p.log.info("  macOS: brew install jq");
+    p.log.info("  Ubuntu: sudo apt install jq");
+    p.outro();
+    process.exit(1);
+  }
+  p.log.success(`Node.js ${nodeVersion}`);
+  p.log.success(`jq ${jqVersion}`);
+  let resolvedClientId = DEFAULT_DISCORD_CLIENT_ID;
+  const existingConfig = existsSync2(CONFIG_FILE);
+  if (existingConfig) {
+    try {
+      const current = JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
+      if (current.discordClientId) {
+        resolvedClientId = current.discordClientId;
+      }
+    } catch {
+    }
+  }
+  const useCustomApp = await p.confirm({
+    message: 'Use a custom Discord app? (default shows as "Claude Code")',
+    initialValue: false
+  });
+  if (p.isCancel(useCustomApp)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  if (useCustomApp) {
+    const clientId = await p.text({
+      message: "Discord Client ID",
+      placeholder: DEFAULT_DISCORD_CLIENT_ID,
+      validate: (value = "") => {
+        if (!value.trim()) return "Client ID is required";
+        if (!/^\d+$/.test(value.trim())) return "Client ID must be numeric";
+      }
+    });
+    if (p.isCancel(clientId)) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    resolvedClientId = clientId.trim();
+  }
+  if (resolvedClientId === DEFAULT_DISCORD_CLIENT_ID) {
+    p.log.info("Using default Client ID");
+  } else {
+    p.log.info(`Using custom Client ID: ${resolvedClientId}`);
+  }
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  const config = {
+    discordClientId: resolvedClientId,
+    daemonPort: DEFAULT_PORT
+  };
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  p.log.success(`Config written to ${CONFIG_FILE}`);
+  let hasClaude = false;
+  try {
+    execSync("which claude", { stdio: "pipe" });
+    hasClaude = true;
+  } catch {
+  }
+  const mcpPath = resolve(__dirname, "mcp", "index.js");
+  if (hasClaude) {
+    try {
+      execSync(`claude mcp add --transport stdio --scope user discord-status -- node ${mcpPath}`, {
+        stdio: "pipe"
+      });
+      p.log.success("MCP server registered");
+    } catch {
+      p.log.warn("Could not register MCP server automatically.");
+      p.log.info(
+        `  Run: claude mcp add --transport stdio --scope user discord-status -- node ${mcpPath}`
+      );
+    }
+  } else {
+    p.log.warn("claude CLI not found \u2014 skipping MCP registration.");
+    p.log.info(
+      `  Run: claude mcp add --transport stdio --scope user discord-status -- node ${mcpPath}`
+    );
+  }
+  const hookScriptPath = resolve(__dirname, "..", "src", "hooks", "claude-hook.sh");
+  const hookCommand = existsSync2(hookScriptPath) ? hookScriptPath : "claude-hook.sh";
+  const claudeSettingsPath = join2(
+    process.env.HOME ?? process.env.USERPROFILE ?? "~",
+    ".claude",
+    "settings.json"
+  );
+  const hookConfig = createHookConfig(hookCommand);
+  try {
+    let existingSettings = {};
+    if (existsSync2(claudeSettingsPath)) {
+      existingSettings = JSON.parse(readFileSync2(claudeSettingsPath, "utf-8"));
+    }
+    const existingHooks = existingSettings.hooks ?? {};
+    const newHooks = hookConfig.hooks;
+    let hooksAdded = 0;
+    let hooksSkipped = 0;
+    for (const [event, entries] of Object.entries(newHooks)) {
+      if (!existingHooks[event]) {
+        existingHooks[event] = [];
+      }
+      for (const entry of entries) {
+        const entryStr = JSON.stringify(entry);
+        const alreadyExists = existingHooks[event].some((e) => JSON.stringify(e) === entryStr);
+        if (!alreadyExists) {
+          existingHooks[event].push(entry);
+          hooksAdded++;
+        } else {
+          hooksSkipped++;
+        }
+      }
+    }
+    existingSettings.hooks = existingHooks;
+    mkdirSync(dirname(claudeSettingsPath), { recursive: true });
+    writeFileSync(claudeSettingsPath, JSON.stringify(existingSettings, null, 2), "utf-8");
+    if (hooksAdded > 0 && hooksSkipped > 0) {
+      p.log.success(`Hooks configured (${hooksAdded} added, ${hooksSkipped} already present)`);
+    } else if (hooksAdded > 0) {
+      p.log.success(`Hooks configured (${hooksAdded} lifecycle events)`);
+    } else {
+      p.log.success("Hooks already configured (no changes)");
+    }
+  } catch (err) {
+    p.log.warn(`Could not configure hooks: ${err.message}`);
+    p.log.info(`  Manually add hooks to ${claudeSettingsPath}`);
+  }
+  const existingPid = getDaemonPid();
+  if (existingPid) {
+    p.log.success(`Daemon already running (PID ${existingPid})`);
+  } else {
+    const daemonPath = resolve(__dirname, "daemon", "index.js");
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    const { openSync } = await import("fs");
+    const logFd = openSync(LOG_FILE, "a");
+    const child = spawn("node", [daemonPath], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env }
+    });
+    child.unref();
+    p.log.success(`Daemon started (PID ${child.pid})`);
+  }
+  const s = p.spinner();
+  s.start("Verifying Discord connection...");
+  await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+  const health = await checkHealth();
+  if (health) {
+    if (health.connected) {
+      s.stop("Discord connected");
+    } else {
+      s.stop("Discord is connecting (open Discord if not running)");
+    }
+  } else {
+    s.stop("Could not reach daemon \u2014 check logs");
+    p.log.info(`  cat ${LOG_FILE}`);
+  }
+  p.note(
+    'Open Discord and check your profile \u2014 you\nshould see "Using Claude Code" as activity.',
+    "Next steps"
+  );
+  p.outro("Setup complete!");
+}
+function createHookConfig(hookCommand) {
+  const syncHook = {
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: hookCommand,
+        timeout: 5
+      }
+    ]
+  };
+  const asyncHook = (matcher) => ({
+    ...matcher ? { matcher } : {},
+    hooks: [
+      {
+        type: "command",
+        command: hookCommand,
+        timeout: 5,
+        async: true
+      }
+    ]
+  });
+  return {
+    hooks: {
+      SessionStart: [syncHook],
+      UserPromptSubmit: [asyncHook()],
+      PreToolUse: [asyncHook("Write|Edit|Bash|Read|Grep|Glob|WebSearch|WebFetch|Task")],
+      Stop: [asyncHook()],
+      Notification: [asyncHook()],
+      SessionEnd: [asyncHook()]
+    }
+  };
+}
+async function uninstall() {
+  p.intro("claude-discord-status");
+  const shouldContinue = await p.confirm({
+    message: "This will remove all hooks, MCP registration, and config. Continue?",
+    initialValue: false
+  });
+  if (p.isCancel(shouldContinue) || !shouldContinue) {
+    p.cancel("Uninstall cancelled.");
+    process.exit(0);
+  }
+  const pid = getDaemonPid();
+  if (pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+      p.log.success(`Daemon stopped (PID ${pid})`);
+    } catch {
+      p.log.info("Daemon process not found, cleaning up PID file.");
+    }
+    try {
+      unlinkSync(PID_FILE);
+    } catch {
+    }
+  } else {
+    p.log.info("Daemon was not running");
+  }
+  try {
+    execSync("claude mcp remove discord-status", { stdio: "pipe" });
+    p.log.success("MCP server removed");
+  } catch {
+    p.log.warn("Could not remove MCP server (may not have been registered)");
+  }
+  const claudeSettingsPath = join2(
+    process.env.HOME ?? process.env.USERPROFILE ?? "~",
+    ".claude",
+    "settings.json"
+  );
+  try {
+    if (existsSync2(claudeSettingsPath)) {
+      const settings = JSON.parse(readFileSync2(claudeSettingsPath, "utf-8"));
+      if (settings.hooks) {
+        for (const event of Object.keys(settings.hooks)) {
+          settings.hooks[event] = settings.hooks[event].filter((entry) => {
+            const str = JSON.stringify(entry);
+            return !str.includes("claude-hook.sh");
+          });
+          if (settings.hooks[event].length === 0) {
+            delete settings.hooks[event];
+          }
+        }
+        if (Object.keys(settings.hooks).length === 0) {
+          delete settings.hooks;
+        }
+        writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        p.log.success("Hooks removed");
+      }
+    }
+  } catch {
+    p.log.warn("Could not clean up hooks");
+  }
+  try {
+    const { rmSync } = await import("fs");
+    rmSync(CONFIG_DIR, { recursive: true, force: true });
+    p.log.success("Config removed");
+  } catch {
+    p.log.warn("Could not remove config directory");
+  }
+  p.outro("Uninstall complete.");
+}
+function showHelp() {
+  p.intro("claude-discord-status");
+  p.note(
+    [
+      "setup        Interactive setup",
+      "start [-d]   Start the daemon (-d for background)",
+      "stop         Stop the daemon",
+      "status       Show daemon status and sessions",
+      "uninstall    Remove all hooks, MCP, and config"
+    ].join("\n"),
+    "Commands"
+  );
+  p.outro("Discord Rich Presence for Claude Code");
+}
+switch (command) {
+  case "start":
+    await startDaemon(args.includes("-d") || args.includes("--daemon"));
+    break;
+  case "stop":
+    await stopDaemon();
+    break;
+  case "status":
+    await showStatus();
+    break;
+  case "setup":
+    await setup();
+    break;
+  case "uninstall":
+    await uninstall();
+    break;
+  default:
+    showHelp();
+    break;
+}
+//# sourceMappingURL=cli.js.map