vibecoder-discord-presence 1.0.0

package/dist/claude-code-Y5EVVTMQ.js

@@ -0,0 +1,114 @@
+import {
+  removeSessionMarker,
+  updateSessionMarker
+} from "./chunk-4V354UFY.js";
+import {
+  isProcessAlive,
+  readLock,
+  spawnDaemon
+} from "./chunk-KDLAS6ED.js";
+import "./chunk-FRGALQ5R.js";
+
+// src/provider/claude-code.ts
+import { readFileSync } from "fs";
+import { basename } from "path";
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function parsePayload(raw) {
+  if (!raw) return null;
+  try {
+    const clean = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+    return JSON.parse(clean);
+  } catch {
+    return null;
+  }
+}
+function fileFromInput(input) {
+  const fp = input?.file_path;
+  return typeof fp === "string" ? basename(fp) : void 0;
+}
+function toolActivity(payload) {
+  const tool = payload.tool_name ?? "";
+  const file = fileFromInput(payload.tool_input);
+  switch (tool) {
+    case "Edit":
+    case "Write":
+    case "MultiEdit":
+    case "NotebookEdit":
+      return { state: "editing", activity: file ? `Editing ${file}` : "Editing", file };
+    case "Read":
+      return { state: "searching", activity: file ? `Reading ${file}` : "Reading", file };
+    case "Bash":
+      return { state: "running", activity: "Running a command" };
+    case "Grep":
+    case "Glob":
+    case "LS":
+      return { state: "searching", activity: "Searching the codebase" };
+    case "WebFetch":
+    case "WebSearch":
+      return { state: "browsing", activity: "Browsing the web" };
+    case "Task":
+    case "Agent":
+      return { state: "delegating", activity: "Running a subagent" };
+    default:
+      return { state: "running", activity: tool ? `Using ${tool}` : "Working" };
+  }
+}
+function activityFor(event, payload) {
+  switch (event) {
+    case "session-start":
+      return { state: "idle", activity: "Starting a session" };
+    case "user-prompt-submit":
+      return { state: "thinking", activity: "Thinking" };
+    case "pre-tool-use":
+      return toolActivity(payload);
+    case "notification":
+      return payload.message?.toLowerCase().includes("permission") ? { state: "waiting", activity: "Waiting for permission" } : { state: "idle", activity: "Idle" };
+    case "stop":
+      return { state: "idle", activity: "Idle" };
+    default:
+      return { state: "idle", activity: "Working" };
+  }
+}
+function ensureDaemon() {
+  const lock = readLock();
+  if (lock && isProcessAlive(lock.pid)) return;
+  spawnDaemon();
+}
+async function runHook(args = []) {
+  try {
+    const event = args[0] ?? "unknown";
+    const payload = parsePayload(readStdin()) ?? {};
+    const id = payload.session_id ?? process.env.CLAUDE_CODE_SESSION_ID;
+    if (!id) return;
+    if (event === "session-end") {
+      removeSessionMarker(id);
+      return;
+    }
+    const now = Date.now();
+    const cwd = payload.cwd ?? process.cwd();
+    const a = activityFor(event, payload);
+    const patch = {
+      cwd,
+      project: basename(cwd),
+      transcriptPath: payload.transcript_path,
+      state: a.state,
+      activity: a.activity,
+      file: a.file
+    };
+    if (event === "session-start" && payload.source !== "compact") {
+      patch.startedAt = now;
+    }
+    updateSessionMarker(id, patch, now);
+    ensureDaemon();
+  } catch {
+  }
+}
+export {
+  runHook
+};

package/dist/config-GLQUOMQ6.js

@@ -0,0 +1,245 @@
+import {
+  renderPresence
+} from "./chunk-XYXO7VLI.js";
+import {
+  DEFAULT_CONFIG,
+  THEMES,
+  readUserConfig,
+  resolveTheme,
+  saveUserConfig
+} from "./chunk-2A7GKQFO.js";
+import {
+  ui
+} from "./chunk-LKE6H3YG.js";
+import {
+  isProcessAlive,
+  readLock
+} from "./chunk-KDLAS6ED.js";
+import {
+  configPath
+} from "./chunk-FRGALQ5R.js";
+
+// src/commands/config.ts
+import { Separator, confirm, input, select } from "@inquirer/prompts";
+var APP_NAME = "ClaudeCode";
+function sampleState(now) {
+  return {
+    sessionCount: 1,
+    startedAt: now - 83e3,
+    // ~1m 23s ago
+    project: "my-app",
+    branch: "main",
+    model: "Opus 4.8",
+    state: "editing",
+    activity: "Editing index.ts",
+    file: "index.ts",
+    tokens: 12345,
+    cost: 0.42
+  };
+}
+function box(lines, title) {
+  const width = Math.max(title.length + 2, ...lines.map((l) => l.length)) + 2;
+  const top = ui.dim("\u250C\u2500 ") + ui.title(title) + ui.dim(` ${"\u2500".repeat(Math.max(0, width - title.length - 3))}\u2510`);
+  const body = lines.map((l) => `${ui.dim("\u2502")} ${l.padEnd(width - 1)}${ui.dim("\u2502")}`);
+  const bottom = ui.dim(`\u2514${"\u2500".repeat(width + 1)}\u2518`);
+  return [top, ...body, bottom].join("\n");
+}
+function previewCard(theme) {
+  const now = Date.now();
+  const p = renderPresence(theme, sampleState(now), now);
+  const lines = [];
+  lines.push(`icon:  ${p.largeImageKey ?? "(none)"}`);
+  lines.push("");
+  lines.push(APP_NAME);
+  if (p.details) lines.push(p.details);
+  if (p.state) lines.push(p.state);
+  if (p.startTimestamp) lines.push("elapsed 01:23");
+  if (p.smallImageKey)
+    lines.push(`badge: ${p.smallImageKey}${p.smallImageText ? ` (${p.smallImageText})` : ""}`);
+  if (p.buttons?.length) lines.push(p.buttons.map((b) => `[ ${b.label} ]`).join(" "));
+  const compact = p.statusDisplayType === 1 ? p.state || `Playing ${APP_NAME}` : p.statusDisplayType === 2 ? p.details || `Playing ${APP_NAME}` : `Playing ${APP_NAME}`;
+  return `${box(lines, "Discord card preview")}
+  ${ui.dim("member list shows:")} ${ui.accent(compact)}`;
+}
+function short(s, max = 30) {
+  const clean = s.replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max - 1)}\u2026` : clean || "(empty)";
+}
+function row(label, value) {
+  return `${label.padEnd(28)} ${ui.dim(`[${value}]`)}`;
+}
+async function editButtons(currentButtons) {
+  const buttons = [];
+  let addMore = await confirm({
+    message: "Add a button? (max 2)",
+    default: currentButtons.length > 0
+  });
+  while (addMore && buttons.length < 2) {
+    const i = buttons.length;
+    const label = await input({
+      message: `Button ${i + 1} label:`,
+      default: currentButtons[i]?.label ?? ""
+    });
+    const url = await input({
+      message: `Button ${i + 1} URL:`,
+      default: currentButtons[i]?.url ?? "",
+      validate: (v) => v.trim() === "" || /^https?:\/\//.test(v.trim()) || "Must start with http(s)://"
+    });
+    if (label.trim() && url.trim()) buttons.push({ label: label.trim(), url: url.trim() });
+    addMore = buttons.length < 2 ? await confirm({ message: "Add another?", default: false }) : false;
+  }
+  return buttons;
+}
+async function editThemeMenu(start) {
+  const t = structuredClone(start);
+  for (; ; ) {
+    console.log(`
+${previewCard(t)}
+`);
+    const choice = await select({
+      message: "Pick a field to edit, or save:",
+      choices: [
+        { name: row("Details \u2014 top line", short(t.details)), value: "details" },
+        { name: row("State \u2014 second line", short(t.state)), value: "state" },
+        { name: row("Timer \u2014 elapsed clock", t.timer ? "on" : "off"), value: "timer" },
+        { name: row("Large image \u2014 big icon", t.largeImage.key), value: "large" },
+        { name: row("Small badge \u2014 corner", t.smallImage.key), value: "small" },
+        { name: row("Buttons", `${t.buttons.length} set`), value: "buttons" },
+        { name: row("Compact status \u2014 member list", t.statusDisplay ?? "name"), value: "status" },
+        new Separator(),
+        { name: ui.ok("\u2713 Save & exit"), value: "__save" },
+        { name: ui.warn("\u2717 Discard changes"), value: "__cancel" }
+      ]
+    });
+    switch (choice) {
+      case "__save":
+        return t;
+      case "__cancel":
+        return null;
+      case "details":
+        t.details = await input({ message: "Details (top line):", default: t.details });
+        break;
+      case "state":
+        t.state = await input({ message: "State (second line):", default: t.state });
+        break;
+      case "timer":
+        t.timer = await confirm({ message: "Show the elapsed timer?", default: t.timer });
+        break;
+      case "large":
+        t.largeImage = {
+          key: await input({ message: "Large image asset key:", default: t.largeImage.key }),
+          text: await input({ message: "Large image tooltip:", default: t.largeImage.text })
+        };
+        break;
+      case "small":
+        t.smallImage = {
+          key: await input({ message: "Small badge asset key:", default: t.smallImage.key }),
+          text: await input({ message: "Small badge tooltip:", default: t.smallImage.text })
+        };
+        break;
+      case "status":
+        t.statusDisplay = await select({
+          message: "Compact member-list status shows:",
+          default: t.statusDisplay ?? "name",
+          choices: [
+            { name: 'App name ("Playing ClaudeCode")', value: "name" },
+            { name: "The state line (your activity)", value: "state" },
+            { name: "The details line", value: "details" }
+          ]
+        });
+        break;
+      case "buttons":
+        t.buttons = await editButtons(t.buttons);
+        break;
+    }
+  }
+}
+function applyNote() {
+  const lock = readLock();
+  if (lock && isProcessAlive(lock.pid)) {
+    return "Your live card will update within ~15s.";
+  }
+  return "It will apply next time you start Claude Code with Discord open.";
+}
+async function config(args = []) {
+  const current = readUserConfig(configPath());
+  if (args.includes("--show")) {
+    console.log(`${ui.dim("theme:")} ${ui.accent(current.theme)}
+`);
+    console.log(previewCard(resolveTheme(current)));
+    return;
+  }
+  if (args.includes("--reset")) {
+    saveUserConfig(DEFAULT_CONFIG);
+    console.log(`${ui.check} reset to the default ${ui.accent('"minimal"')} theme.`);
+    console.log(`  ${ui.dim(applyNote())}`);
+    return;
+  }
+  try {
+    console.log(
+      `
+${ui.title("Customize your Discord presence")} ${ui.dim("\u2014 Ctrl+C to cancel")}
+`
+    );
+    console.log(
+      ui.dim(
+        "Tip: text fields accept placeholders like {project} {branch} {model} {file} {activity} {elapsed}.\n"
+      )
+    );
+    const theme = await select({
+      message: "Pick a theme:",
+      default: current.theme,
+      choices: [
+        { name: "minimal   \u2014 privacy-safe, nothing about your work", value: "minimal" },
+        { name: "developer \u2014 project, branch, file, model", value: "developer" },
+        { name: "focus     \u2014 deep-work timer", value: "focus" },
+        { name: "playful   \u2014 vibey", value: "playful" },
+        { name: "chaos     \u2014 \u{1F680} every stat, all the emojis, peak vibes", value: "chaos" },
+        { name: "custom    \u2014 edit every field yourself", value: "custom" }
+      ]
+    });
+    let next;
+    if (theme === "custom") {
+      const edited = await editThemeMenu(resolveTheme(current));
+      if (!edited) {
+        console.log(ui.warn("Cancelled \u2014 no changes saved."));
+        return;
+      }
+      next = { theme: "custom", overrides: edited, clientId: current.clientId };
+    } else {
+      console.log(`
+${previewCard(THEMES[theme])}
+`);
+      const action = await select({
+        message: `Use "${theme}" as-is, or customize it?`,
+        choices: [
+          { name: `Use ${theme} as-is`, value: "asis" },
+          { name: "Customize \u2014 edit fields, then save", value: "edit" }
+        ]
+      });
+      if (action === "asis") {
+        next = { theme, overrides: {}, clientId: current.clientId };
+      } else {
+        const edited = await editThemeMenu(structuredClone(THEMES[theme]));
+        if (!edited) {
+          console.log(ui.warn("Cancelled \u2014 no changes saved."));
+          return;
+        }
+        next = { theme: "custom", overrides: edited, clientId: current.clientId };
+      }
+    }
+    saveUserConfig(next);
+    console.log(`
+${ui.check} ${ui.bold("Saved")} ${ui.dim(`to ${configPath()}`)}`);
+    console.log(`  ${ui.dim(applyNote())}`);
+  } catch (err) {
+    if (err instanceof Error && err.name === "ExitPromptError") {
+      console.log(ui.warn("\nCancelled \u2014 no changes saved."));
+      return;
+    }
+    throw err;
+  }
+}
+export {
+  config
+};

package/dist/daemon-UR7HFYY7.js

@@ -0,0 +1,276 @@
+import {
+  renderPresence
+} from "./chunk-XYXO7VLI.js";
+import {
+  readUserConfig,
+  resolveClientId,
+  resolveTheme
+} from "./chunk-2A7GKQFO.js";
+import {
+  PRUNE_AFTER_MS,
+  aggregate,
+  readMarkers,
+  removeSessionMarker
+} from "./chunk-4V354UFY.js";
+import {
+  acquireLock,
+  clearDaemonStatus,
+  releaseLock,
+  writeDaemonStatus
+} from "./chunk-KDLAS6ED.js";
+import {
+  configPath
+} from "./chunk-FRGALQ5R.js";
+
+// src/provider/transcript.ts
+import { readFileSync, statSync } from "fs";
+var cache = /* @__PURE__ */ new Map();
+function prettyModel(raw) {
+  const m = /claude-(opus|sonnet|haiku)-(\d+)-(\d+)/.exec(raw);
+  if (!m) return raw;
+  const tier = m[1].charAt(0).toUpperCase() + m[1].slice(1);
+  return `${tier} ${m[2]}.${m[3]}`;
+}
+function parse(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return {};
+  }
+  let model;
+  let branch;
+  let tokens = 0;
+  let sawTokens = false;
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof entry.gitBranch === "string" && entry.gitBranch && entry.gitBranch !== "HEAD") {
+      branch = entry.gitBranch;
+    }
+    const msg = entry.message;
+    if (msg && typeof msg === "object") {
+      if (typeof msg.model === "string" && msg.model && msg.model !== "<synthetic>") {
+        model = msg.model;
+      }
+      const out = msg.usage?.output_tokens;
+      if (typeof out === "number") {
+        tokens += out;
+        sawTokens = true;
+      }
+    }
+  }
+  return {
+    model: model ? prettyModel(model) : void 0,
+    branch,
+    tokens: sawTokens ? tokens : void 0
+  };
+}
+function readTranscriptMeta(transcriptPath) {
+  if (!transcriptPath) return {};
+  let st;
+  try {
+    st = statSync(transcriptPath);
+  } catch {
+    return {};
+  }
+  const cached = cache.get(transcriptPath);
+  if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+    return cached.meta;
+  }
+  const meta = parse(transcriptPath);
+  cache.set(transcriptPath, { mtimeMs: st.mtimeMs, size: st.size, meta });
+  return meta;
+}
+
+// src/daemon/discord.ts
+import { Client } from "@xhayper/discord-rpc";
+var CONNECT_TIMEOUT_MS = 1e4;
+function withTimeout(p, ms, label) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out`)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    );
+  });
+}
+function toSetActivity(p) {
+  return {
+    details: p.details,
+    state: p.state,
+    largeImageKey: p.largeImageKey,
+    largeImageText: p.largeImageText,
+    smallImageKey: p.smallImageKey,
+    smallImageText: p.smallImageText,
+    startTimestamp: p.startTimestamp,
+    buttons: p.buttons,
+    statusDisplayType: p.statusDisplayType
+  };
+}
+var DiscordPresence = class {
+  constructor(clientId) {
+    this.clientId = clientId;
+  }
+  clientId;
+  client;
+  connected = false;
+  connecting = false;
+  get isConnected() {
+    return this.connected;
+  }
+  /** Ensure we have a live connection. Returns false (no-op) if Discord is down. */
+  async ensureClient() {
+    if (this.connected && this.client) return true;
+    if (this.connecting) return false;
+    if (!this.clientId) return false;
+    this.connecting = true;
+    if (this.client) {
+      try {
+        await this.client.destroy();
+      } catch {
+      }
+      this.client = void 0;
+    }
+    try {
+      const client = new Client({ clientId: this.clientId, transport: { type: "ipc" } });
+      client.on("disconnected", () => {
+        this.connected = false;
+      });
+      try {
+        await withTimeout(client.connect(), CONNECT_TIMEOUT_MS, "discord connect");
+      } catch (err) {
+        try {
+          await client.destroy();
+        } catch {
+        }
+        throw err;
+      }
+      const transportSocket = client.transport.socket;
+      transportSocket?.on("error", () => {
+        this.connected = false;
+      });
+      this.client = client;
+      this.connected = true;
+      return true;
+    } catch {
+      this.connected = false;
+      return false;
+    } finally {
+      this.connecting = false;
+    }
+  }
+  async setActivity(payload) {
+    if (Object.keys(payload).length === 0) {
+      await this.clearActivity();
+      return;
+    }
+    if (!await this.ensureClient()) return;
+    try {
+      await this.client?.user?.setActivity(toSetActivity(payload));
+    } catch {
+      this.connected = false;
+    }
+  }
+  async clearActivity() {
+    if (!this.connected || !this.client) return;
+    try {
+      await this.client.user?.clearActivity();
+    } catch {
+      this.connected = false;
+    }
+  }
+  async destroy() {
+    try {
+      await this.client?.destroy();
+    } catch {
+    }
+    this.client = void 0;
+    this.connected = false;
+  }
+};
+
+// src/daemon/index.ts
+var TICK_MS = 15 * 1e3;
+var IDLE_GRACE_MS = 60 * 1e3;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function startDaemon(_args = []) {
+  if (!acquireLock(Date.now())) return;
+  const discord = new DiscordPresence(resolveClientId(readUserConfig(configPath())));
+  let running = true;
+  const shutdown = async () => {
+    running = false;
+    await discord.clearActivity();
+    await discord.destroy();
+    clearDaemonStatus();
+    releaseLock();
+  };
+  process.once("SIGINT", () => void shutdown().then(() => process.exit(0)));
+  process.once("SIGTERM", () => void shutdown().then(() => process.exit(0)));
+  process.on("exit", () => releaseLock());
+  const RECOVERABLE = /* @__PURE__ */ new Set([
+    "ECONNRESET",
+    "EPIPE",
+    "ECONNREFUSED",
+    "ENOENT",
+    "EBADF",
+    "ERR_STREAM_DESTROYED"
+  ]);
+  process.on("uncaughtException", (err) => {
+    if (RECOVERABLE.has(err.code ?? "")) return;
+    void shutdown().finally(() => process.exit(1));
+  });
+  process.on("unhandledRejection", () => {
+  });
+  let idleSince = null;
+  while (running) {
+    const now = Date.now();
+    const markers = readMarkers();
+    const state = aggregate(markers, now);
+    for (const m of markers) {
+      if (now - m.heartbeat > PRUNE_AFTER_MS) removeSessionMarker(m.id);
+    }
+    if (state) {
+      idleSince = null;
+      const meta = readTranscriptMeta(state.transcriptPath);
+      state.model ??= meta.model;
+      state.branch ??= meta.branch;
+      state.tokens ??= meta.tokens;
+      const theme = resolveTheme(readUserConfig(configPath()));
+      await discord.setActivity(renderPresence(theme, state, now));
+      writeDaemonStatus({
+        pid: process.pid,
+        connected: discord.isConnected,
+        sessionCount: state.sessionCount,
+        activity: state.activity,
+        updatedAt: now
+      });
+    } else {
+      if (idleSince === null) idleSince = now;
+      await discord.clearActivity();
+      writeDaemonStatus({
+        pid: process.pid,
+        connected: discord.isConnected,
+        sessionCount: 0,
+        updatedAt: now
+      });
+      if (now - idleSince >= IDLE_GRACE_MS) break;
+    }
+    await sleep(TICK_MS);
+  }
+  await shutdown();
+}
+export {
+  startDaemon
+};

package/dist/install-PS6R32NO.js

@@ -0,0 +1,45 @@
+import {
+  HOOK_EVENTS,
+  backupSettings,
+  mergeHooks,
+  readSettings,
+  writeSettings
+} from "./chunk-CEWLOUQO.js";
+import {
+  DEFAULT_CONFIG
+} from "./chunk-2A7GKQFO.js";
+import {
+  ui
+} from "./chunk-LKE6H3YG.js";
+import {
+  configPath,
+  entryPath,
+  presenceDir,
+  sessionsDir
+} from "./chunk-FRGALQ5R.js";
+
+// src/commands/install.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+async function install(_args = []) {
+  await mkdir(sessionsDir(), { recursive: true });
+  if (!existsSync(configPath())) {
+    await mkdir(presenceDir(), { recursive: true });
+    await writeFile(configPath(), `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
+`);
+  }
+  const existing = await readSettings();
+  const backupPath = await backupSettings(existing);
+  await writeSettings(mergeHooks(existing, entryPath()));
+  console.log(`${ui.check} ${ui.bold("vibecoder-discord-presence installed")}`);
+  console.log(`  ${ui.dim("hooks:")}  ${HOOK_EVENTS.map((e) => e.name).join(", ")}`);
+  console.log(`  ${ui.dim("config:")} ${ui.accent(configPath())}`);
+  if (backupPath) console.log(`  ${ui.dim("backup:")} ${ui.accent(backupPath)}`);
+  console.log(
+    `
+${ui.dim("Open Claude Code with Discord running and your presence will appear.")}`
+  );
+}
+export {
+  install
+};

package/dist/restart-4QW7NSWI.js

@@ -0,0 +1,28 @@
+import {
+  ui
+} from "./chunk-LKE6H3YG.js";
+import {
+  isProcessAlive,
+  readLock,
+  spawnDaemon,
+  stopDaemon
+} from "./chunk-KDLAS6ED.js";
+import "./chunk-FRGALQ5R.js";
+
+// src/commands/restart.ts
+async function restart(_args = []) {
+  const old = await stopDaemon();
+  if (old) console.log(ui.dim(`  stopped daemon (pid ${old})`));
+  spawnDaemon();
+  await new Promise((r) => setTimeout(r, 1e3));
+  const lock = readLock();
+  if (lock && isProcessAlive(lock.pid)) {
+    console.log(`${ui.check} ${ui.bold("daemon restarted")} ${ui.dim(`(pid ${lock.pid})`)}`);
+  } else {
+    console.log(`${ui.check} ${ui.bold("daemon restart triggered")}`);
+    console.log(ui.dim("  (it shows a card once a Claude Code session is active)"));
+  }
+}
+export {
+  restart
+};