zombie-vibe 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zombie Vibe
+
+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,56 @@
+# Zombie Vibe Hooks
+
+Zombie Vibe installs deterministic prompt-submission hooks for Codex, Claude Code, Cursor, Windsurf, and Grok. The hook records when a prompt was submitted, the editor and session, the local timezone offset, and prompt length. It immediately discards the prompt text.
+
+Events live in a private persistent queue at `~/.zombie-vibe/events.jsonl`. When the queue reaches 10 events, the oldest 10 are sent to the Zombie Vibe API. Failed uploads stay queued for a later prompt or manual flush.
+
+## Install
+
+Create an API key after signing in at `https://cloudcodesarena.xyz/#account`, then install globally for every supported editor:
+
+```bash
+npx zombie-vibe install --api-key zp_live_YOUR_KEY
+```
+
+Install for one editor:
+
+```bash
+npx zombie-vibe install --editor codex --api-key zp_live_YOUR_KEY
+npx zombie-vibe install --editor claude --api-key zp_live_YOUR_KEY
+npx zombie-vibe install --editor cursor --api-key zp_live_YOUR_KEY
+npx zombie-vibe install --editor windsurf --api-key zp_live_YOUR_KEY
+npx zombie-vibe install --editor grok --api-key zp_live_YOUR_KEY
+```
+
+The installer copies a stable runtime to `~/.zombie-vibe/hook.mjs`, stores the key in a mode-`0600` config file, merges the hook into the editor's existing JSON, and creates a backup before every edit. Restart an open editor after installation.
+
+## Hook locations
+
+| Editor | Global configuration | Event |
+| --- | --- | --- |
+| Codex CLI/Desktop | `~/.codex/hooks.json` | `UserPromptSubmit` |
+| Claude Code/Desktop | `~/.claude/settings.json` | `UserPromptSubmit` |
+| Cursor | `~/.cursor/hooks.json` | `beforeSubmitPrompt` |
+| Windsurf | `~/.codeium/windsurf/hooks.json` | `pre_user_prompt` |
+| Grok | `~/.grok/hooks/zombie-vibe.json` | `UserPromptSubmit` |
+
+## Operations
+
+```bash
+npx zombie-vibe status
+npx zombie-vibe flush
+```
+
+## Manual installation
+
+Copy `runtime/hook.mjs` to `~/.zombie-vibe/hook.mjs`, copy `examples/config.json` to `~/.zombie-vibe/config.json`, replace the API-key placeholder, and restrict the config with `chmod 600 ~/.zombie-vibe/config.json`. Then merge the relevant file from `examples/` into the editor configuration shown above. Replace `--agent codex` with `--agent claude` or `--agent grok` when using the Claude-compatible example for those editors.
+
+## Publish to npm
+
+Update the version, confirm the package name and repository URL, authenticate with `npm login`, then run:
+
+```bash
+npm run publish:npm
+```
+
+The publishing script runs tests, previews the package tarball, verifies npm authentication, and publishes publicly.

package/bin/zombie-vibe.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { install, printHelp, showStatus } from "../lib/installer.mjs";
+import { captureFromStdin, flushQueue } from "../runtime/hook.mjs";
+
+const [command = "help", ...args] = process.argv.slice(2);
+
+try {
+  if (command === "install") await install(args);
+  else if (command === "status") await showStatus();
+  else if (command === "capture") await captureFromStdin(args);
+  else if (command === "flush") await flushQueue({ force: true });
+  else if (["help", "--help", "-h"].includes(command)) printHelp();
+  else {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exitCode = 1;
+  }
+} catch (error) {
+  console.error(`Zombie Vibe: ${error instanceof Error ? error.message : error}`);
+  process.exitCode = 1;
+}

package/examples/claude-or-codex-hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/ABSOLUTE/PATH/TO/.zombie-vibe/hook.mjs\" --agent codex",
+            "timeout": 5,
+            "async": true
+          }
+        ]
+      }
+    ]
+  }
+}

package/examples/config.json

@@ -0,0 +1,5 @@
+{
+  "apiUrl": "https://api.codersarena.xyz/api/v1/events",
+  "apiKey": "zp_live_REPLACE_WITH_YOUR_KEY",
+  "batchSize": 10
+}

package/examples/cursor-hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "beforeSubmitPrompt": [
+      {
+        "command": "node \"/ABSOLUTE/PATH/TO/.zombie-vibe/hook.mjs\" --agent cursor",
+        "timeout": 5
+      }
+    ]
+  }
+}

package/examples/windsurf-hooks.json

@@ -0,0 +1,10 @@
+{
+  "hooks": {
+    "pre_user_prompt": [
+      {
+        "command": "node \"/ABSOLUTE/PATH/TO/.zombie-vibe/hook.mjs\" --agent windsurf",
+        "show_output": false
+      }
+    ]
+  }
+}

package/lib/installer.mjs

@@ -0,0 +1,117 @@
+import { chmod, copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const home = homedir();
+const runtimeDir = join(home, ".zombie-vibe");
+const runtimePath = join(runtimeDir, "hook.mjs");
+const configPath = join(runtimeDir, "config.json");
+const supported = ["codex", "claude", "cursor", "windsurf", "grok"];
+
+function option(args, name) {
+  const equals = args.find((arg) => arg.startsWith(`${name}=`));
+  if (equals) return equals.slice(name.length + 1);
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function shellQuote(value) {
+  return `"${String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+async function readJson(path, fallback = {}) {
+  try { return JSON.parse(await readFile(path, "utf8")); } catch (error) {
+    if (error?.code === "ENOENT") return fallback;
+    throw new Error(`Cannot parse ${path}. Fix the JSON and run install again.`);
+  }
+}
+
+async function writeJson(path, value, privateFile = false) {
+  await mkdir(dirname(path), { recursive: true });
+  if (existsSync(path)) await copyFile(path, `${path}.zombie-vibe.backup`);
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: privateFile ? 0o600 : 0o644 });
+  await rename(temp, path);
+  if (privateFile) await chmod(path, 0o600);
+}
+
+function nestedHook(command) {
+  return { hooks: [{ type: "command", command, timeout: 5, async: true }] };
+}
+
+function addUnique(list, entry) {
+  const current = Array.isArray(list) ? list : [];
+  return current.some((item) => JSON.stringify(item).includes(".zombie-vibe")) ? current : [...current, entry];
+}
+
+export function upsertHook(editor, document, command) {
+  const output = { ...document, hooks: { ...(document.hooks || {}) } };
+  if (editor === "cursor") {
+    output.version ||= 1;
+    output.hooks.beforeSubmitPrompt = addUnique(output.hooks.beforeSubmitPrompt, { command, timeout: 5 });
+  } else if (editor === "windsurf") {
+    output.hooks.pre_user_prompt = addUnique(output.hooks.pre_user_prompt, { command, show_output: false });
+  } else {
+    output.hooks.UserPromptSubmit = addUnique(output.hooks.UserPromptSubmit, nestedHook(command));
+  }
+  return output;
+}
+
+function hookFile(editor) {
+  return {
+    codex: join(home, ".codex", "hooks.json"),
+    claude: join(home, ".claude", "settings.json"),
+    cursor: join(home, ".cursor", "hooks.json"),
+    windsurf: join(home, ".codeium", "windsurf", "hooks.json"),
+    grok: join(home, ".grok", "hooks", "zombie-vibe.json"),
+  }[editor];
+}
+
+export async function install(args) {
+  const requested = (option(args, "--editor") || "all").toLowerCase();
+  const editors = requested === "all" ? supported : requested.split(",").map((value) => value.trim());
+  const unknown = editors.filter((editor) => !supported.includes(editor));
+  if (unknown.length) throw new Error(`Unsupported editor: ${unknown.join(", ")}. Use ${supported.join(", ")}, or all.`);
+  const apiKey = option(args, "--api-key") || process.env.ZOMBIE_VIBE_API_KEY;
+  const apiUrl = (option(args, "--api-url") || "https://api.codersarena.xyz/api/v1/events").replace(/\/$/, "");
+
+  await mkdir(runtimeDir, { recursive: true });
+  await copyFile(join(packageRoot, "runtime", "hook.mjs"), runtimePath);
+  const existing = await readJson(configPath, {});
+  await writeJson(configPath, { apiUrl, apiKey: apiKey || existing.apiKey || "", batchSize: 10, installedAt: new Date().toISOString() }, true);
+
+  for (const editor of editors) {
+    const path = hookFile(editor);
+    const command = `${shellQuote(process.execPath)} ${shellQuote(runtimePath)} --agent ${editor}`;
+    await writeJson(path, upsertHook(editor, await readJson(path, {}), command));
+    console.log(`✓ ${editor.padEnd(8)} ${path}`);
+  }
+  console.log(`✓ runtime  ${runtimePath}`);
+  console.log(`✓ config   ${configPath}`);
+  if (!apiKey) console.log("! No API key yet. Re-run with --api-key zp_live_… before expecting uploads.");
+  console.log("\nHooks are installed globally. Restart open editors so they reload their configuration.");
+}
+
+export async function showStatus() {
+  const config = await readJson(configPath, {});
+  const queuePath = join(runtimeDir, "events.jsonl");
+  const queued = existsSync(queuePath) ? (await readFile(queuePath, "utf8")).split("\n").filter(Boolean).length : 0;
+  console.log(JSON.stringify({ installed: existsSync(runtimePath), configured: Boolean(config.apiKey), apiUrl: config.apiUrl, queued, hooks: Object.fromEntries(supported.map((editor) => [editor, existsSync(hookFile(editor))])) }, null, 2));
+}
+
+export function printHelp() {
+  console.log(`Zombie Vibe prompt hooks
+
+Usage:
+  npx zombie-vibe install --api-key zp_live_…
+  npx zombie-vibe install --editor codex --api-key zp_live_…
+  npx zombie-vibe install --editor claude,cursor --api-key zp_live_…
+  npx zombie-vibe status
+  npx zombie-vibe flush
+
+Editors: codex, claude, cursor, windsurf, grok, all (default)
+Privacy: prompt text is read only to calculate its length, then discarded.`);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "zombie-vibe",
+  "version": "0.1.0",
+  "description": "Install privacy-first prompt timing hooks for Codex, Claude Code, Cursor, Windsurf, and Grok.",
+  "type": "module",
+  "bin": {
+    "zombie-vibe": "bin/zombie-vibe.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "runtime/",
+    "examples/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "pack:check": "npm pack --dry-run",
+    "publish:npm": "bash scripts/publish-npm.sh"
+  },
+  "keywords": ["codex", "claude-code", "cursor", "windsurf", "grok", "hooks", "developer-wellness"],
+  "license": "MIT",
+  "engines": { "node": ">=20" },
+  "repository": { "type": "git", "url": "git+https://github.com/codersarena/zombie-vibe-skills.git" },
+  "homepage": "https://cloudcodesarena.xyz/#integrations"
+}

package/runtime/hook.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+
+const dataDir = join(homedir(), ".zombie-vibe");
+const configPath = join(dataDir, "config.json");
+const queuePath = join(dataDir, "events.jsonl");
+const lockPath = join(dataDir, "events.lock");
+
+function arg(name, args = process.argv.slice(2)) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function promptFrom(payload) {
+  const candidate = payload?.prompt ?? payload?.user_prompt ?? payload?.message ?? payload?.tool_info?.user_prompt ?? payload?.input?.prompt ?? "";
+  return typeof candidate === "string" ? candidate : JSON.stringify(candidate || "");
+}
+
+export function eventFromPayload(payload, agent = "unknown", now = new Date()) {
+  const prompt = promptFrom(payload);
+  const session = payload?.session_id ?? payload?.sessionId ?? payload?.conversation_id ?? payload?.trajectory_id ?? `anonymous-${randomBytes(6).toString("hex")}`;
+  return {
+    id: randomBytes(12).toString("base64url"),
+    occurred_at: now.toISOString(),
+    agent: String(agent).slice(0, 40),
+    session_id: String(session).slice(0, 160),
+    prompt_length: [...prompt].length,
+    timezone_offset_minutes: now.getTimezoneOffset(),
+  };
+}
+
+async function readJson(path, fallback) {
+  try { return JSON.parse(await readFile(path, "utf8")); } catch { return fallback; }
+}
+
+async function lock() {
+  await mkdir(dataDir, { recursive: true });
+  for (let attempt = 0; attempt < 80; attempt += 1) {
+    try { return await open(lockPath, "wx", 0o600); } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+  }
+  throw new Error("queue is busy; next prompt will retry");
+}
+
+async function withQueue(operation) {
+  const handle = await lock();
+  try {
+    let events = [];
+    try { events = (await readFile(queuePath, "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line)); } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+    const next = await operation(events);
+    const temp = `${queuePath}.${process.pid}.tmp`;
+    await writeFile(temp, next.map((event) => JSON.stringify(event)).join("\n") + (next.length ? "\n" : ""), { mode: 0o600 });
+    await rename(temp, queuePath);
+    return next;
+  } finally {
+    await handle.close();
+    await unlink(lockPath).catch(() => {});
+  }
+}
+
+async function sendBatch(config, events) {
+  if (!config.apiKey || !config.apiUrl) return false;
+  const response = await fetch(config.apiUrl, {
+    method: "POST",
+    headers: { authorization: `Bearer ${config.apiKey}`, "content-type": "application/json", "user-agent": "zombie-vibe-hook/0.1.0" },
+    body: JSON.stringify({ events }),
+    signal: AbortSignal.timeout(3000),
+  });
+  return response.ok;
+}
+
+export async function capture(payload, agent) {
+  const config = await readJson(configPath, { batchSize: 10 });
+  const batchSize = Math.max(1, Math.min(10, Number(config.batchSize || 10)));
+  await withQueue(async (events) => {
+    events.push(eventFromPayload(payload, agent));
+    if (events.length < batchSize) return events;
+    try {
+      const batch = events.slice(0, batchSize);
+      return await sendBatch(config, batch) ? events.slice(batchSize) : events;
+    } catch { return events; }
+  });
+}
+
+export async function flushQueue({ force = false } = {}) {
+  const config = await readJson(configPath, { batchSize: 10 });
+  const batchSize = Math.max(1, Math.min(10, Number(config.batchSize || 10)));
+  let sent = 0;
+  await withQueue(async (events) => {
+    if (!events.length || (!force && events.length < batchSize)) return events;
+    const count = force ? Math.min(batchSize, events.length) : batchSize;
+    try {
+      if (await sendBatch(config, events.slice(0, count))) { sent = count; return events.slice(count); }
+    } catch {}
+    return events;
+  });
+  return sent;
+}
+
+export async function captureFromStdin(args = process.argv.slice(2)) {
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) input += chunk;
+  let payload = {};
+  try { payload = JSON.parse(input || "{}"); } catch {}
+  await capture(payload, arg("--agent", args) || "unknown");
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  captureFromStdin().catch(() => { process.exitCode = 0; });
+}