vibecoder-discord-presence 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Younesfdj
+
+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,87 @@
+<div align="center">
+  <img src="assets/logo.jpg" alt="" width="160" height="160" align="middle" />
+  <h1>
+    Vibecoder Discord Presence
+  </h1>
+  <p><strong>Your AI coding sessions, live on Discord.</strong></p>
+
+<img src="assets/demo.gif" alt="demo" width="480" />
+
+</div>
+
+A live Discord status for your AI coding sessions — thinking, editing, running
+tests, as it happens. Theme it however you like (or build your own from scratch),
+and it stays private unless you choose to share more.
+
+## Supported tools
+
+| Tool        | Status       |
+| ----------- | ------------ |
+| Claude Code | ✅ supported |
+| Gemini CLI  | 🔜 planned   |
+| Codex       | 🔜 planned   |
+| OpenCode    | 🔜 planned   |
+
+> Built on a provider model — adding a tool only changes how events are read, not
+> the rest. PRs welcome.
+
+## Install
+
+```sh
+npm i -g vibecoder-discord-presence
+```
+
+## Setup
+
+```sh
+vdp install
+```
+
+Open your AI coding tool with the Discord **desktop** app running — your status
+shows up on its own. That's the whole setup.
+
+> Needs Node 18+ and the Discord desktop app.
+
+## Themes
+
+Five built-ins, from privacy-safe to maximum vibes.
+
+<p align="center">
+  <img src="assets/profile.png" alt="Discord rich presence" width="320"/>
+</p>
+
+`minimal` · `developer` · `focus` · `playful` · `chaos`
+
+## Customize
+
+```sh
+vdp config
+```
+
+Pick a theme or build your own — every line, image, and button — with a live
+preview as you go.
+
+## Commands
+
+| Command                    | What it does                                   |
+| -------------------------- | ---------------------------------------------- |
+| `vdp install`              | Set it up                                      |
+| `vdp config`               | Customize the card                             |
+| `vdp status`               | See what's running                             |
+| `vdp stop` / `vdp restart` | Control the background process                 |
+| `vdp uninstall [--purge]`  | Remove it (`--purge` also deletes your config) |
+
+## Privacy
+
+The default `minimal` theme shares nothing about your work — no project names,
+paths, or filenames. Anything more is opt-in, and there's no telemetry.
+
+## How it works
+
+A small hook fires on each event and writes a marker file. A lightweight
+background process reads it, updates Discord, and exits once you're idle — no
+always-on daemon, no manual start/stop.
+
+## License
+
+[MIT](LICENSE) © [younesfdj](https://github.com/younesfdj)

package/dist/chunk-2A7GKQFO.js

@@ -0,0 +1,108 @@
+import {
+  configPath
+} from "./chunk-FRGALQ5R.js";
+
+// src/themes/index.ts
+var REPO_URL = "https://github.com/younesfdj/vibecoder-discord-presence";
+var THEMES = {
+  minimal: {
+    details: "Coding with Claude Code",
+    state: "",
+    largeImage: { key: "logo", text: "Claude Code" },
+    smallImage: { key: "status-{state}", text: "{activity}" },
+    timer: true,
+    buttons: [],
+    // No state line; let the compact status show the activity from details.
+    statusDisplay: "details"
+  },
+  developer: {
+    details: "Coding {project} ({branch})",
+    state: "{activity} \xB7 {model}",
+    largeImage: { key: "logo", text: "Claude Code \xB7 {model}" },
+    smallImage: { key: "status-{state}", text: "{activity}" },
+    timer: true,
+    buttons: [{ label: "\u2B50 Star on GitHub", url: REPO_URL }],
+    statusDisplay: "state"
+  },
+  focus: {
+    details: "In a deep work session \u{1F3AF}",
+    state: "Focused for {elapsed}",
+    largeImage: { key: "focus", text: "Deep work" },
+    smallImage: { key: "status-focus", text: "Focusing" },
+    timer: true,
+    buttons: [],
+    statusDisplay: "state"
+  },
+  playful: {
+    details: "\u{1F916} vibecoding with Claude",
+    state: "shipping {project} \xB7 {model}",
+    largeImage: { key: "logo", text: "vibecoder" },
+    smallImage: { key: "status-{state}", text: "{activity}" },
+    timer: true,
+    buttons: [{ label: "get vibecoder", url: REPO_URL }],
+    statusDisplay: "state"
+  },
+  chaos: {
+    details: "\u{1F680} {activity} \u2014 \u{1F4C2} {project} {branch} \u{1F4BB}\u{1F525}",
+    state: "cooking with {model} \xB7 {tokens} tokens burned\xB7 {cost} \xB7 \u{1F465} {sessionCount} \xB7 \u231B {elapsed}",
+    largeImage: { key: "logo", text: "\u2728 locked in \xB7 {model} \xB7 no thoughts only vibes \u{1F525}" },
+    smallImage: { key: "status-{state}", text: "{activity} fr fr \u{1F4AF}" },
+    timer: true,
+    buttons: [
+      { label: "\u{1F525} join the vibe", url: REPO_URL },
+      { label: "\u2728 star (real)", url: REPO_URL }
+    ],
+    statusDisplay: "details"
+  }
+};
+var DEFAULT_THEME = "minimal";
+
+// src/core/config.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var DEFAULT_CONFIG = {
+  theme: DEFAULT_THEME,
+  overrides: {}
+};
+var DEFAULT_CLIENT_ID = "1511730102499541123";
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+function readUserConfig(configPath2) {
+  try {
+    const raw = stripBom(readFileSync(configPath2, "utf8"));
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return DEFAULT_CONFIG;
+    return {
+      theme: typeof parsed.theme === "string" ? parsed.theme : DEFAULT_CONFIG.theme,
+      overrides: typeof parsed.overrides === "object" && parsed.overrides !== null ? parsed.overrides : {},
+      clientId: typeof parsed.clientId === "string" ? parsed.clientId : void 0
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function resolveTheme(config) {
+  const base = THEMES[config.theme] ?? THEMES[DEFAULT_THEME];
+  return { ...base, ...config.overrides ?? {} };
+}
+function resolveClientId(config) {
+  return process.env.VDP_DISCORD_CLIENT_ID || config.clientId || DEFAULT_CLIENT_ID;
+}
+function saveUserConfig(config) {
+  const dest = configPath();
+  mkdirSync(dirname(dest), { recursive: true });
+  const tmp = `${dest}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`);
+  renameSync(tmp, dest);
+}
+
+export {
+  THEMES,
+  DEFAULT_CONFIG,
+  readUserConfig,
+  resolveTheme,
+  resolveClientId,
+  saveUserConfig
+};

package/dist/chunk-4V354UFY.js

@@ -0,0 +1,90 @@
+import {
+  sessionsDir
+} from "./chunk-FRGALQ5R.js";
+
+// src/core/state.ts
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+var STALE_AFTER_MS = 20 * 60 * 1e3;
+var PRUNE_AFTER_MS = 60 * 60 * 1e3;
+function markerPath(id) {
+  return join(sessionsDir(), `${id}.json`);
+}
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+function writeSessionMarker(marker) {
+  const dir = sessionsDir();
+  mkdirSync(dir, { recursive: true });
+  const dest = markerPath(marker.id);
+  const tmp = `${dest}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(marker));
+  renameSync(tmp, dest);
+}
+function readSessionMarker(id) {
+  try {
+    const raw = stripBom(readFileSync(markerPath(id), "utf8"));
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function updateSessionMarker(id, patch, now) {
+  const existing = readSessionMarker(id);
+  const merged = {
+    id,
+    startedAt: existing?.startedAt ?? now,
+    ...existing,
+    ...patch,
+    heartbeat: now
+  };
+  writeSessionMarker(merged);
+}
+function removeSessionMarker(id) {
+  try {
+    rmSync(markerPath(id));
+  } catch {
+  }
+}
+function readMarkers() {
+  let files;
+  try {
+    files = readdirSync(sessionsDir());
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of files) {
+    if (!f.endsWith(".json")) continue;
+    const m = readSessionMarker(f.slice(0, -5));
+    if (m) out.push(m);
+  }
+  return out;
+}
+function aggregate(markers, now, staleAfterMs = STALE_AFTER_MS) {
+  const live = markers.filter((m) => now - m.heartbeat <= staleAfterMs);
+  if (live.length === 0) return null;
+  const current = live.reduce((a, b) => b.heartbeat > a.heartbeat ? b : a);
+  const startedAt = live.reduce((min, m) => Math.min(min, m.startedAt), Infinity);
+  return {
+    sessionCount: live.length,
+    startedAt,
+    transcriptPath: current.transcriptPath,
+    project: current.project,
+    branch: current.branch,
+    model: current.model,
+    state: current.state,
+    activity: current.activity,
+    file: current.file,
+    tokens: current.tokens,
+    cost: current.cost
+  };
+}
+
+export {
+  PRUNE_AFTER_MS,
+  updateSessionMarker,
+  removeSessionMarker,
+  readMarkers,
+  aggregate
+};

package/dist/chunk-CEWLOUQO.js

@@ -0,0 +1,97 @@
+import {
+  claudeDir,
+  settingsPath
+} from "./chunk-FRGALQ5R.js";
+
+// src/core/settings.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+var HOOK_MARKER = "vdp.js";
+var HOOK_EVENTS = [
+  { name: "SessionStart", arg: "session-start" },
+  { name: "UserPromptSubmit", arg: "user-prompt-submit" },
+  { name: "PreToolUse", arg: "pre-tool-use" },
+  { name: "Notification", arg: "notification" },
+  { name: "Stop", arg: "stop" },
+  { name: "SessionEnd", arg: "session-end" }
+];
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+async function readSettings() {
+  try {
+    const raw = stripBom(await readFile(settingsPath(), "utf8"));
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return {};
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeSettings(settings) {
+  const dest = settingsPath();
+  await mkdir(dirname(dest), { recursive: true });
+  const tmp = `${dest}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(settings, null, 2)}
+`);
+  await rename(tmp, dest);
+}
+async function backupSettings(settings) {
+  if (Object.keys(settings).length === 0) return null;
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const path = `${settingsPath()}.${ts}.bak`;
+  await mkdir(claudeDir(), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}
+`);
+  return path;
+}
+function isOurEntry(entry) {
+  if (!Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER));
+}
+function buildEntry(entryPath, arg) {
+  return {
+    matcher: "*",
+    hooks: [{ type: "command", command: `node "${entryPath}" hook ${arg}` }]
+  };
+}
+function mergeHooks(settings, entryPath) {
+  const hooks = { ...settings.hooks ?? {} };
+  for (const event of HOOK_EVENTS) {
+    const existing = (hooks[event.name] ?? []).filter((e) => !isOurEntry(e));
+    existing.push(buildEntry(entryPath, event.arg));
+    hooks[event.name] = existing;
+  }
+  return { ...settings, hooks };
+}
+function stripOurHooks(settings) {
+  const inHooks = settings.hooks;
+  if (inHooks === void 0) return { cleaned: settings, removed: 0 };
+  let removed = 0;
+  const outHooks = {};
+  for (const [event, entries] of Object.entries(inHooks)) {
+    const kept = entries.filter((e) => {
+      if (isOurEntry(e)) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    if (kept.length > 0) outHooks[event] = kept;
+  }
+  const cleaned = { ...settings };
+  if (Object.keys(outHooks).length > 0) cleaned.hooks = outHooks;
+  else delete cleaned.hooks;
+  return { cleaned, removed };
+}
+
+export {
+  HOOK_EVENTS,
+  readSettings,
+  writeSettings,
+  backupSettings,
+  isOurEntry,
+  mergeHooks,
+  stripOurHooks
+};

package/dist/chunk-FRGALQ5R.js

@@ -0,0 +1,39 @@
+// src/core/paths.ts
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+function entryPath() {
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "vdp.js");
+}
+function claudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+}
+function settingsPath() {
+  return path.join(claudeDir(), "settings.json");
+}
+function presenceDir() {
+  return path.join(claudeDir(), "discord-presence");
+}
+function configPath() {
+  return path.join(presenceDir(), "config.json");
+}
+function statePath() {
+  return path.join(presenceDir(), "state.json");
+}
+function lockPath() {
+  return path.join(presenceDir(), "daemon.lock");
+}
+function sessionsDir() {
+  return path.join(presenceDir(), "sessions");
+}
+
+export {
+  entryPath,
+  claudeDir,
+  settingsPath,
+  presenceDir,
+  configPath,
+  statePath,
+  lockPath,
+  sessionsDir
+};

package/dist/chunk-KDLAS6ED.js

@@ -0,0 +1,126 @@
+import {
+  entryPath,
+  lockPath,
+  presenceDir,
+  statePath
+} from "./chunk-FRGALQ5R.js";
+
+// src/core/daemon-state.ts
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { spawn } from "child_process";
+var DAEMON_STATUS_STALE_MS = 60 * 1e3;
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readLock() {
+  try {
+    return JSON.parse(stripBom(readFileSync(lockPath(), "utf8")));
+  } catch {
+    return null;
+  }
+}
+function acquireLock(now) {
+  mkdirSync(presenceDir(), { recursive: true });
+  const payload = JSON.stringify({ pid: process.pid, startedAt: now });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      writeFileSync(lockPath(), payload, { flag: "wx" });
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      const existing = readLock();
+      if (existing && existing.pid !== process.pid && isProcessAlive(existing.pid)) {
+        return false;
+      }
+      try {
+        rmSync(lockPath());
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function releaseLock() {
+  const existing = readLock();
+  if (existing && existing.pid === process.pid) {
+    try {
+      rmSync(lockPath());
+    } catch {
+    }
+  }
+}
+function writeDaemonStatus(status) {
+  try {
+    mkdirSync(presenceDir(), { recursive: true });
+    const dest = statePath();
+    const tmp = `${dest}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(status));
+    renameSync(tmp, dest);
+  } catch {
+  }
+}
+function readDaemonStatus() {
+  try {
+    return JSON.parse(stripBom(readFileSync(statePath(), "utf8")));
+  } catch {
+    return null;
+  }
+}
+function clearDaemonStatus() {
+  try {
+    rmSync(statePath());
+  } catch {
+  }
+}
+async function waitForExit(pid, timeoutMs) {
+  const step = 100;
+  for (let waited = 0; waited < timeoutMs; waited += step) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, step));
+  }
+  return !isProcessAlive(pid);
+}
+async function stopDaemon(timeoutMs = 2e3) {
+  const lock = readLock();
+  if (!lock || !isProcessAlive(lock.pid)) return null;
+  try {
+    process.kill(lock.pid, "SIGTERM");
+  } catch {
+    return null;
+  }
+  await waitForExit(lock.pid, timeoutMs);
+  return lock.pid;
+}
+function spawnDaemon() {
+  try {
+    const child = spawn(process.execPath, [entryPath(), "daemon"], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+      // don't flash a console window on Windows
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+export {
+  DAEMON_STATUS_STALE_MS,
+  isProcessAlive,
+  readLock,
+  acquireLock,
+  releaseLock,
+  writeDaemonStatus,
+  readDaemonStatus,
+  clearDaemonStatus,
+  stopDaemon,
+  spawnDaemon
+};

package/dist/chunk-LKE6H3YG.js

@@ -0,0 +1,28 @@
+// src/ui.ts
+import pc from "picocolors";
+var ui = {
+  /** Bold cyan heading. */
+  title: (s) => pc.bold(pc.cyan(s)),
+  /** Success text (green). */
+  ok: (s) => pc.green(s),
+  /** Error text (red). */
+  err: (s) => pc.red(s),
+  /** Warning / attention text (yellow). */
+  warn: (s) => pc.yellow(s),
+  /** Accent for values, commands, URLs (cyan). */
+  accent: (s) => pc.cyan(s),
+  /** Secondary / muted text (dim). */
+  dim: (s) => pc.dim(s),
+  /** Emphasis (bold). */
+  bold: (s) => pc.bold(s),
+  /** Green check glyph. */
+  check: pc.green("\u2713"),
+  /** Red cross glyph. */
+  cross: pc.red("\u2717"),
+  /** Muted bullet glyph. */
+  bullet: pc.dim("\u2022")
+};
+
+export {
+  ui
+};

package/dist/chunk-XYXO7VLI.js

@@ -0,0 +1,65 @@
+// src/core/presence.ts
+function formatElapsed(ms) {
+  const total = Math.max(0, Math.floor(ms / 1e3));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  if (h > 0) return `${h}h ${m}m`;
+  if (m > 0) return `${m}m`;
+  return `${total}s`;
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function buildValues(state, now) {
+  return {
+    project: state.project ?? "",
+    branch: state.branch ?? "",
+    model: state.model ?? "",
+    activity: state.activity ?? "",
+    file: state.file ?? "",
+    tokens: state.tokens != null ? formatTokens(state.tokens) : "",
+    cost: state.cost != null ? `$${state.cost.toFixed(2)}` : "",
+    elapsed: formatElapsed(now - state.startedAt),
+    sessionCount: String(state.sessionCount),
+    // Drives the `status-{state}` badge; also available as a text token.
+    state: state.state ?? "idle"
+  };
+}
+function tidy(s) {
+  return s.replace(/\(\s*\)/g, "").replace(/\[\s*\]/g, "").replace(/\s+/g, " ").replace(/·(\s*·)+/g, "\xB7").replace(/^\s*·\s*/, "").replace(/\s*·\s*$/, "").trim();
+}
+function interpolate(template, values) {
+  return tidy(template.replace(/\{(\w+)\}/g, (_, key) => values[key] ?? ""));
+}
+function renderPresence(theme, state, now) {
+  const values = buildValues(state, now);
+  const payload = {};
+  const details = interpolate(theme.details, values);
+  if (details) payload.details = details;
+  const stateLine = interpolate(theme.state, values);
+  if (stateLine) payload.state = stateLine;
+  const largeKey = interpolate(theme.largeImage.key, values);
+  if (largeKey) {
+    payload.largeImageKey = largeKey;
+    const largeText = interpolate(theme.largeImage.text, values);
+    if (largeText) payload.largeImageText = largeText;
+  }
+  const smallKey = interpolate(theme.smallImage.key, values);
+  if (smallKey) {
+    payload.smallImageKey = smallKey;
+    const smallText = interpolate(theme.smallImage.text, values);
+    if (smallText) payload.smallImageText = smallText;
+  }
+  if (theme.timer) payload.startTimestamp = state.startedAt;
+  if (theme.statusDisplay === "state" && payload.state) payload.statusDisplayType = 1;
+  else if (theme.statusDisplay === "details" && payload.details) payload.statusDisplayType = 2;
+  const buttons = theme.buttons.map((b) => ({ label: interpolate(b.label, values), url: b.url })).filter((b) => b.label && b.url).slice(0, 2);
+  if (buttons.length > 0) payload.buttons = buttons;
+  return payload;
+}
+
+export {
+  renderPresence
+};