@vibevibes/mcp 0.9.2 → 0.9.5

package/hooks/stop-hook.js

@@ -2,20 +2,15 @@
 /**
  * vibevibes Stop Hook
  *
- * Scans .claude/vibevibes-agents/ for agent files, discovers AI agents from
- * the server, polls each for events, and returns to Claude when there's activity.
- *
- * Self-healing: reconciles agent files against server, cleans stale files,
- * and exits gracefully when no AI participants remain.
- *
- * Shipped with @vibevibes/mcp.
+ * Checks if the agent is connected to an experience.
+ * If connected, checks for events ONCE (no polling, no timeout).
+ * Returns immediately so user input is never blocked.
  */
 import { readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { execSync } from "node:child_process";
 import { makeDecision } from "./logic.js";
 // ── Helpers ────────────────────────────────────────────────
-/** Resolve project root: git root or cwd */
 function resolveProjectRoot() {
     try {
         return execSync("git rev-parse --show-toplevel", { encoding: "utf-8", timeout: 3000 }).trim();
@@ -26,8 +21,6 @@ function resolveProjectRoot() {
 }
 const PROJECT_ROOT = resolveProjectRoot();
 const AGENTS_DIR = process.env.VIBEVIBES_AGENTS_DIR || resolve(PROJECT_ROOT, ".claude", "vibevibes-agents");
-const DEFAULT_TIMEOUT = 5000;
-/** Read JSON from stdin (Claude Code passes hook context here) */
 function readStdin() {
     return new Promise((res) => {
         let data = "";
@@ -45,7 +38,6 @@ function readStdin() {
             res({});
     });
 }
-/** Load all agent files from AGENTS_DIR. Returns array of session objects. */
 function loadAgentFiles() {
     if (!existsSync(AGENTS_DIR))
         return [];
@@ -55,7 +47,7 @@ function loadAgentFiles() {
             .map((f) => {
             try {
                 const data = JSON.parse(readFileSync(resolve(AGENTS_DIR, f), "utf-8"));
-                data._filename = f; // Track filename for iteration updates
+                data._filename = f;
                 return data;
             }
             catch {
@@ -68,83 +60,39 @@ function loadAgentFiles() {
         return [];
     }
 }
-/** Increment and persist the iteration counter in an agent file */
 function bumpIteration(agent) {
     const iter = (agent.iteration || 0) + 1;
     try {
         const filePath = resolve(AGENTS_DIR, agent._filename || `${agent.owner}.json`);
-        // Use in-memory agent data instead of re-reading from disk to avoid
-        // race conditions with concurrent stop-hook processes.
         const data = { ...agent };
-        delete data._filename; // internal field, not persisted
+        delete data._filename;
         data.iteration = iter;
         writeFileSync(filePath, JSON.stringify(data, null, 2));
     }
-    catch {
-        // Non-fatal — iteration tracking is best-effort
-    }
+    catch { }
     return iter;
 }
-/** Delete owned agent files and exit.
- *  If no filenames specified, deletes all agent files (fallback for SIGINT/SIGTERM). */
-let _cleaningUp = false;
-function cleanupAndExit(ownedFilenames) {
-    if (_cleaningUp)
-        process.exit(0);
-    _cleaningUp = true;
-    if (existsSync(AGENTS_DIR)) {
-        try {
-            if (ownedFilenames && ownedFilenames.length > 0) {
-                // Only delete agent files owned by this stop-hook invocation
-                for (const f of ownedFilenames) {
-                    try {
-                        unlinkSync(resolve(AGENTS_DIR, f));
-                    }
-                    catch { /* ignore */ }
-                }
-            }
-            else {
-                // Fallback: delete all (SIGINT/SIGTERM where ourAgents is unknown)
-                for (const f of readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".json"))) {
-                    try {
-                        unlinkSync(resolve(AGENTS_DIR, f));
-                    }
-                    catch { /* ignore */ }
-                }
-            }
-        }
-        catch { /* ignore */ }
-    }
-    process.exit(0);
-}
-/** Delete a specific agent file by owner name */
 function deleteAgentFile(owner) {
     try {
         unlinkSync(resolve(AGENTS_DIR, `${owner}.json`));
     }
-    catch { /* ignore */ }
+    catch { }
 }
-// Session end cleanup — SIGINT (Ctrl+C), SIGTERM (process kill)
-process.on("SIGINT", () => cleanupAndExit());
-process.on("SIGTERM", () => cleanupAndExit());
 // ── Main ───────────────────────────────────────────────────
 async function main() {
     await readStdin();
-    // H1. Read agent files
+    // Load agent files — if none, we're not connected, allow exit
     const agents = loadAgentFiles();
     if (agents.length === 0) {
         process.exit(0);
     }
-    // Use the first agent file for server/room info (all should be same server)
     const session = agents[0];
-    // H2. Reconciliation — verify agents exist on server, clean stale files.
+    // Quick reconciliation — check if our agents still exist on server
     try {
-        const sUrl = session.serverUrl;
-        const rId = session.roomId;
-        const participantsUrl = rId
-            ? `${sUrl}/rooms/${rId}/participants`
-            : `${sUrl}/participants`;
-        const res = await fetch(participantsUrl, { signal: AbortSignal.timeout(3000) });
+        const participantsUrl = session.roomId
+            ? `${session.serverUrl}/rooms/${session.roomId}/participants`
+            : `${session.serverUrl}/participants`;
+        const res = await fetch(participantsUrl, { signal: AbortSignal.timeout(2000) });
         if (res.ok) {
             const data = await res.json();
             if (Array.isArray(data?.participants)) {
@@ -155,117 +103,62 @@ async function main() {
                     }
                 }
                 if (!data.participants.some((p) => p.type === "ai")) {
-                    cleanupAndExit();
+                    // No AI participants on server — clean up and allow exit
+                    for (const a of agents)
+                        deleteAgentFile(a.owner);
+                    process.exit(0);
                 }
             }
         }
     }
     catch {
-        // Server unreachable — proceed to poll (don't delete files)
+        // Server unreachable — still block to keep agent alive
     }
-    // In-memory cursor per agent (not written to disk)
-    const cursors = new Map(); // actorId → lastEventCursor
-    // Build the list of OUR agents from agent files.
-    const ourAgents = agents
-        .filter(a => existsSync(resolve(AGENTS_DIR, a._filename || `${a.owner}.json`)))
-        .map((a) => ({
-        actorId: a.actorId,
-        owner: a.owner,
-        role: a.role || undefined,
-        iteration: a.iteration || 0,
-        _filename: a._filename,
-        serverUrl: a.serverUrl || session.serverUrl,
-        roomId: a.roomId || undefined,
-    }));
-    if (ourAgents.length === 0) {
-        cleanupAndExit(agents.map(a => a._filename || `${a.owner}.json`));
-        return;
+    // Check for events ONCE — no polling, no timeout, instant return
+    const agent = agents[0];
+    if (!agent.actorId) {
+        // Connected but no actorId — block exit to stay alive
+        process.stdout.write(JSON.stringify({ decision: "block", reason: "Connected. Waiting." }));
+        process.exit(0);
     }
-    // Poll loop — runs until events arrive or no agents remain.
-    // Wall-clock limit: exit after 55 seconds to stay within Claude Code's hook timeout.
-    const POLL_DEADLINE_MS = 55_000;
-    const pollStart = Date.now();
-    while (true) {
-        // Wall-clock guard — exit cleanly before Claude Code kills us
-        const elapsed = Date.now() - pollStart;
-        if (elapsed > POLL_DEADLINE_MS) {
+    try {
+        const ownerParam = agent.owner ? `&owner=${encodeURIComponent(agent.owner)}` : "";
+        const roomP = agent.roomId ? `&roomId=${encodeURIComponent(agent.roomId)}` : "";
+        // timeout=0 means don't long-poll, just return immediately
+        const url = `${agent.serverUrl}/agent-context?since=0&actorId=${encodeURIComponent(agent.actorId)}&timeout=0${ownerParam}${roomP}`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok) {
+            // Server error — block exit to stay alive
+            process.stdout.write(JSON.stringify({ decision: "block", reason: "Connected. Server returned error." }));
             process.exit(0);
         }
-        // Cap poll timeout to remaining time minus buffer, so we don't overshoot the deadline
-        const remainingMs = POLL_DEADLINE_MS - elapsed;
-        const pollTimeout = Math.min(DEFAULT_TIMEOUT, Math.max(1000, remainingMs - 3000));
-        // Poll only OUR agents (from agent files) in parallel
-        const results = await Promise.all(ourAgents.map(async (agent) => {
-            const ctx = await pollAgent(agent.serverUrl, agent.roomId, agent, cursors, pollTimeout);
-            return { agent, ctx };
-        }));
-        // Update cursors from server responses
-        for (const { agent, ctx } of results) {
-            if (ctx?.eventCursor != null && agent.actorId) {
-                cursors.set(agent.actorId, ctx.eventCursor);
-            }
-        }
-        // Handle done signals — clean up agent file if experience says done
-        const doneOwners = new Set();
-        for (const { agent, ctx } of results) {
-            if (!ctx)
-                continue;
-            if (ctx.observation?.done) {
-                deleteAgentFile(agent.owner);
-                doneOwners.add(agent.owner);
-            }
-        }
-        // Check if any agent got null context (possibly evicted from server or network blip)
-        const stillAlive = results.filter((r) => r.ctx !== null);
-        if (stillAlive.length === 0) {
-            // Don't delete agent files on transient failure — just exit quietly so retry can succeed
+        const ctx = await res.json();
+        // Check for done signal
+        if (ctx.observation?.done) {
+            deleteAgentFile(agent.owner);
             process.exit(0);
-            return;
         }
-        // Filter to agents with actionable events
-        let live = results.filter((r) => r.ctx && ((r.ctx.events && r.ctx.events.length > 0) ||
-            r.ctx.lastError ||
-            r.ctx.observeError ||
-            (r.ctx.browserErrors != null && r.ctx.browserErrors.length > 0)));
-        if (live.length > 0) {
-            if (live.length > 1) {
-                process.stderr.write(`[vibevibes] Warning: ${live.length} agent files found but expected 1. Using first agent only.\n`);
-            }
-            const { agent, ctx } = live[0];
-            const iteration = doneOwners.has(agent.owner) ? (agent.iteration || 0) + 1 : bumpIteration(agent);
+        // Check for actionable events
+        const hasEvents = (ctx.events && ctx.events.length > 0) ||
+            ctx.lastError ||
+            ctx.observeError ||
+            (ctx.browserErrors != null && ctx.browserErrors.length > 0);
+        if (hasEvents) {
+            const iteration = bumpIteration(agent);
             const decision = makeDecision(ctx, iteration);
             if (decision) {
                 process.stdout.write(JSON.stringify(decision));
             }
             process.exit(0);
         }
-        // No events — loop again (the server's long-poll IS the delay)
-    }
-}
-/** Poll a single agent's server for events */
-async function pollAgent(serverUrl, roomId, agent, cursors, timeout = DEFAULT_TIMEOUT) {
-    const { actorId, owner } = agent;
-    if (!actorId)
-        return null;
-    const since = cursors.get(actorId) || 0;
-    const ownerParam = owner ? `&owner=${encodeURIComponent(owner)}` : "";
-    const roomP = roomId ? `&roomId=${encodeURIComponent(roomId)}` : "";
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeout + 1000);
-    try {
-        const url = `${serverUrl}/agent-context?since=${since}&actorId=${encodeURIComponent(actorId)}&timeout=${timeout}${ownerParam}${roomP}`;
-        const res = await fetch(url, { signal: controller.signal });
-        if (!res.ok)
-            return null;
-        return await res.json();
+        // No events — still connected, block exit
+        process.stdout.write(JSON.stringify({ decision: "block", reason: "Connected. No new events." }));
+        process.exit(0);
     }
     catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timer);
+        // Network error — block exit to keep agent alive
+        process.stdout.write(JSON.stringify({ decision: "block", reason: "Connected. Checking..." }));
+        process.exit(0);
     }
 }
-main().catch(() => {
-    process.exit(0);
-});
+main().catch(() => process.exit(0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibevibes/mcp",
-  "version": "0.9.2",
+  "version": "0.9.5",
   "description": "MCP server — connects Claude to vibevibes experiences",
   "type": "module",
   "main": "dist/index.js",