slashvibe-mcp 0.5.7 → 0.5.9

package/index.js

@@ -71,6 +71,7 @@ function inferPromptFromArgs(toolName, args) {
     case 'reservations': return 'list reservations';
     case 'solo_game': return `play ${args.game || 'game'}`;
     case 'game': return `play ${args.game || 'game'} with ${handle}`;
+    case 'poem': return args.line ? `add a line to poem with ${handle}` : `emoji poem with ${handle}`;
     case 'multiplayer_game': return `multiplayer ${args.game || 'game'}`;
     case 'drawing': return args.action ? `drawing ${args.action}` : 'collaborative drawing';
     case 'crossword': return `crossword ${args.action || 'daily'}`;
@@ -255,6 +256,11 @@ const coreTools = {
   vibe_ship: require('./tools/ship'),
   vibe_feed: require('./tools/feed'),
 
+  // Play — the original January magic: shared experiences over the DM transport
+  vibe_game: require('./tools/game'),
+  vibe_poem: require('./tools/poem'),
+  vibe_corpse: require('./tools/corpse'),
+
   // Matrix rooms — multiplayer
   vibe_matrix_rooms: require('./tools/matrix-rooms'),
   vibe_matrix_read: require('./tools/matrix-read'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Social layer for Claude Code - DMs, presence, Matrix multiplayer rooms, and connection between AI-assisted developers",
   "main": "index.js",

package/store/api.js

@@ -694,15 +694,22 @@ async function getThread(myHandle, theirHandle) {
       console.error('[getThread] V2 failed, falling back to v1');
     }
 
-    // V1 fallback
+    // V1 fallback — live /api/messages returns { messages: [...] } with snake_case
+    // fields (body, created_at, source_client). Older builds returned { thread: [...] }
+    // with (text, createdAt). Accept BOTH shapes so the read path survives whichever
+    // the server sends — otherwise payload-bearing DMs (games, poems) silently vanish
+    // and every turn reads as a fresh game. This is the path the game/poem tools rely
+    // on while the v2 /threads/:id detail route is unavailable.
     const result = await request('GET', `/api/messages?user=${myHandle}&with=${theirHandle}`);
-    return (result.thread || []).map(m => ({
+    const rows = result.messages || result.thread || [];
+    return rows.map(m => ({
       from: m.from,
       isAgent: m.isAgent || m.is_agent || false, // Support both naming conventions
-      body: m.text,
+      body: m.body ?? m.text,
       payload: m.payload || null,
-      timestamp: new Date(m.createdAt).getTime(),
-      direction: m.direction
+      source_client: m.source_client || null,
+      timestamp: new Date(m.created_at || m.createdAt).getTime(),
+      direction: m.direction || (m.from === myHandle ? 'sent' : 'received'),
     }));
   } catch (e) {
     console.error('Thread failed:', e.message);

package/tools/corpse.js

@@ -0,0 +1,269 @@
+/**
+ * vibe corpse — Write an exquisite corpse together, one line at a time
+ *
+ * The surrealist parlor game, ported to the terminal. Two people build a story
+ * (or a poem) by alternating lines — but you only ever see the LAST line the
+ * other person wrote, never the whole thing. When someone seals it, the full
+ * corpse is revealed to both, usually gloriously nonsensical.
+ *
+ * Same transport as `vibe poem` / `vibe game`: the story state travels in the
+ * DM message payload (durable via the Postgres payload column), passed back and
+ * forth over the DM thread. The only new idea here is that render hides every
+ * line but the last until the story is sealed.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Corpses seal automatically at this many lines (either player can seal earlier).
+const MAX_LINES = 10;
+
+/**
+ * Find the most recent corpse state in a DM thread.
+ */
+function getCorpseState(thread) {
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const p = thread[i].payload;
+    if (p && p.type === 'corpse' && p.state) return p.state;
+  }
+  return null;
+}
+
+function uniqueAuthors(lines) {
+  const seen = [];
+  for (const l of lines) if (!seen.includes(l.author)) seen.push(l.author);
+  return seen;
+}
+
+/**
+ * Render the full, revealed corpse (only shown once sealed).
+ */
+function renderReveal(state) {
+  const lines = state.lines || [];
+  let out = '💀 **exquisite corpse';
+  if (state.title) out += ` — ${state.title}`;
+  out += '**\n\n';
+  if (!lines.length) {
+    out += '_(empty — nothing was written)_\n';
+  } else {
+    out += '```\n';
+    for (const l of lines) out += `${l.text}\n`;
+    out += '```\n';
+    out += `\n_by ${uniqueAuthors(lines).map((a) => '@' + a).join(' & ')} — ${lines.length} lines_\n`;
+  }
+  return out;
+}
+
+/**
+ * Render the *in-progress* corpse: the whole story stays folded, you only see
+ * the last line to build from. This is the whole point of the game.
+ */
+function renderFolded(state, me) {
+  const lines = state.lines || [];
+  let out = '💀 **exquisite corpse';
+  if (state.title) out += ` — ${state.title}`;
+  out += '**\n\n';
+  if (!lines.length) {
+    out += '_(blank page — write the opening line; the rest stays hidden)_\n';
+    return out;
+  }
+  const last = lines[lines.length - 1];
+  const hiddenCount = lines.length - 1;
+  out += '```\n';
+  if (hiddenCount > 0) {
+    out += `… ${hiddenCount} line${hiddenCount === 1 ? '' : 's'} folded out of sight …\n`;
+  }
+  out += `${last.text}\n`;
+  out += '```\n';
+  out += `\n_only the last line shows — continue from it, blind to the rest_\n`;
+  return out;
+}
+
+/**
+ * Whose turn is it? Alternate off the last line's author. If the last line was
+ * mine, it's their turn; if theirs (or empty), it's mine.
+ */
+function isMyTurn(state, me) {
+  const lines = state.lines || [];
+  if (!lines.length) return true; // whoever opens goes first
+  return lines[lines.length - 1].author !== me;
+}
+
+async function postCorpseToBoard(state, authors) {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+  const body = (state.lines || []).map((l) => l.text).join(' / ');
+  try {
+    await fetch(`${API_URL}/api/board`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        author: 'echo',
+        content: `${authors.map((a) => '@' + a).join(' & ')} unfolded an exquisite corpse: ${body}`,
+        category: 'general',
+      }),
+    });
+  } catch (e) {
+    console.error('[corpse] Failed to post to board:', e.message);
+  }
+}
+
+const definition = {
+  name: 'vibe_corpse',
+  description:
+    'Write an exquisite corpse together — a surrealist story where you only ever see the LAST line, never the whole thing, until it is sealed and revealed. Pass it back and forth: each turn adds a line, blind to what came before. `vibe corpse @handle --line "the clock swallowed its own hands"`',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to write with (e.g., @solienne)',
+      },
+      line: {
+        type: 'string',
+        description: 'The line to add — builds from the last visible line only',
+      },
+      title: {
+        type: 'string',
+        description: 'Optional title, only used when starting a new corpse',
+      },
+      done: {
+        type: 'boolean',
+        description: 'Seal the corpse after adding your line, revealing the whole thing to both of you',
+      },
+      reveal: {
+        type: 'boolean',
+        description: 'Show the full revealed corpse (only works once it has been sealed)',
+      },
+    },
+    required: ['handle'],
+  },
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { line, title, done, reveal } = args;
+  const me = config.getHandle();
+  const them = normalizeHandle(args.handle);
+
+  if (them === me) {
+    return { display: "You can't play exquisite corpse with yourself — half the fun is the surprise. Invite someone: `vibe corpse @handle`." };
+  }
+
+  const thread = await store.getThread(me, them);
+  let state = getCorpseState(thread);
+
+  // Explicit reveal request.
+  if (reveal) {
+    if (!state) {
+      return { display: `No corpse with @${them} yet. Start one: \`vibe corpse @${them} --line "…"\`` };
+    }
+    if (!state.done) {
+      return {
+        display:
+          `That corpse isn't sealed yet — no peeking! 💀\n\n${renderFolded(state, me)}\n` +
+          (isMyTurn(state, me)
+            ? `Your turn — add a line: \`vibe corpse @${them} --line "…"\``
+            : `Waiting for @${them} to add the next line…`),
+      };
+    }
+    return { display: `## exquisite corpse with @${them}\n\n${renderReveal(state)}` };
+  }
+
+  // No line provided → show current status (folded), or start a fresh corpse.
+  if (!line) {
+    if (!state) {
+      const newState = { lines: [], title: title || null, done: false, startedBy: me };
+      await store.sendMessage(
+        me,
+        them,
+        `Let's play exquisite corpse 💀 A surrealist story where you only see my last line. Add yours: \`vibe corpse @${me} --line "…"\``,
+        'dm',
+        { type: 'corpse', state: newState }
+      );
+      return {
+        display:
+          `## New exquisite corpse with @${them}\n\n${renderFolded(newState, me)}\n` +
+          `Write the opening line: \`vibe corpse @${them} --line "the moon filed a complaint"\``,
+      };
+    }
+
+    // Show existing corpse (folded unless sealed).
+    if (state.done) {
+      return {
+        display:
+          `## exquisite corpse with @${them}\n\n${renderReveal(state)}\n` +
+          `✨ Sealed. Start another: \`vibe corpse @${them} --line "…"\``,
+      };
+    }
+    let display = `## exquisite corpse with @${them}\n\n${renderFolded(state, me)}\n`;
+    if (isMyTurn(state, me)) {
+      display += `\nYour turn — add a line (blind to the rest): \`vibe corpse @${them} --line "…"\``;
+    } else {
+      display += `\nWaiting for @${them} to add the next line…`;
+    }
+    return { display };
+  }
+
+  // Adding a line.
+  if (!state) {
+    state = { lines: [], title: title || null, done: false, startedBy: me };
+  }
+
+  if (state.done) {
+    return {
+      display:
+        `This corpse is already sealed 💀\n\n${renderReveal(state)}\n` +
+        `Start a new one: \`vibe corpse @${them} --line "…"\``,
+    };
+  }
+
+  if (!isMyTurn(state, me)) {
+    return {
+      display:
+        `It's @${them}'s turn to add a line.\n\n${renderFolded(state, me)}\n` +
+        `Nudge them, or wait for their line.`,
+    };
+  }
+
+  const text = String(line).trim();
+  if (!text) return { display: 'Give me a line to add: `vibe corpse @handle --line "…"`' };
+  if (text.length > 200) return { display: 'Keep each line under 200 characters.' };
+
+  const newLines = [...(state.lines || []), { author: me, text }];
+  const shouldSeal = done === true || newLines.length >= MAX_LINES;
+  const newState = {
+    ...state,
+    lines: newLines,
+    done: shouldSeal,
+  };
+
+  const authors = uniqueAuthors(newLines);
+  let message;
+  if (shouldSeal) {
+    // On seal, the full corpse is revealed — send it in the DM so both sides see it.
+    message =
+      `Sealed our exquisite corpse 💀✨ Here's the whole thing, unfolded:\n\n` +
+      newLines.map((l) => l.text).join('\n');
+    if (authors.length > 1) postCorpseToBoard(newState, authors);
+  } else {
+    // Mid-game: only tell them it's their turn. Do NOT echo the story — keep it folded.
+    message = `Added a line to our corpse — your turn 💀 You'll only see my last line:\n"${text}"`;
+  }
+
+  await store.sendMessage(me, them, message, 'dm', { type: 'corpse', state: newState });
+
+  if (shouldSeal) {
+    let display = `## exquisite corpse with @${them}\n\n${renderReveal(newState)}\n`;
+    display += `\n✨ Corpse sealed${newLines.length >= MAX_LINES ? ` (${MAX_LINES} lines)` : ''} and revealed to you both. Start another anytime.`;
+    return { display };
+  }
+
+  let display = `## exquisite corpse with @${them}\n\n${renderFolded(newState, me)}\n`;
+  display += `\nYour line is in. Sent to @${them}, folded away — waiting for theirs…`;
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/poem.js

@@ -0,0 +1,208 @@
+/**
+ * vibe poem — Write an emoji poem together, one line at a time
+ *
+ * The original January /vibe magic: two people co-authoring something small
+ * and playful inside Claude Code, passed back and forth over the DM transport.
+ * Each turn adds a line; the poem state travels in the message payload (durable
+ * via the Postgres payload column), exactly like `vibe game`.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Poems seal automatically at this many lines (either player can seal earlier).
+const MAX_LINES = 8;
+
+/**
+ * Find the most recent poem state in a DM thread.
+ */
+function getPoemState(thread) {
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const p = thread[i].payload;
+    if (p && p.type === 'poem' && p.state) return p.state;
+  }
+  return null;
+}
+
+/**
+ * Render a poem for the terminal.
+ */
+function renderPoem(state, { withMe, them } = {}) {
+  const lines = state.lines || [];
+  let out = '📜 **emoji poem';
+  if (state.title) out += ` — ${state.title}`;
+  out += '**\n\n';
+  if (!lines.length) {
+    out += '_(blank page — add the first line)_\n';
+  } else {
+    out += '```\n';
+    for (const l of lines) out += `${l.text}\n`;
+    out += '```\n';
+    out += `\n_by ${uniqueAuthors(lines).map((a) => '@' + a).join(' & ')}_\n`;
+  }
+  return out;
+}
+
+function uniqueAuthors(lines) {
+  const seen = [];
+  for (const l of lines) if (!seen.includes(l.author)) seen.push(l.author);
+  return seen;
+}
+
+/**
+ * Whose turn is it? Alternate off the last line's author. If the last line was
+ * mine, it's their turn; if theirs (or empty), it's mine.
+ */
+function isMyTurn(state, me) {
+  const lines = state.lines || [];
+  if (!lines.length) return true; // whoever opens goes first
+  return lines[lines.length - 1].author !== me;
+}
+
+async function postPoemToBoard(state, authors) {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+  const body = (state.lines || []).map((l) => l.text).join(' / ');
+  try {
+    await fetch(`${API_URL}/api/board`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        author: 'echo',
+        content: `${authors.map((a) => '@' + a).join(' & ')} finished an emoji poem: ${body}`,
+        category: 'general',
+      }),
+    });
+  } catch (e) {
+    console.error('[poem] Failed to post to board:', e.message);
+  }
+}
+
+const definition = {
+  name: 'vibe_poem',
+  description:
+    'Write an emoji poem together, one line at a time. Pass it back and forth with someone — each turn adds a line. `vibe poem @handle --line "🌊🌙 the tide remembers"`',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to write with (e.g., @solienne)',
+      },
+      line: {
+        type: 'string',
+        description: 'The line to add (emoji-forward, but any text welcome)',
+      },
+      title: {
+        type: 'string',
+        description: 'Optional title, only used when starting a new poem',
+      },
+      done: {
+        type: 'boolean',
+        description: 'Seal the poem as finished after adding your line',
+      },
+    },
+    required: ['handle'],
+  },
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { line, title, done } = args;
+  const me = config.getHandle();
+  const them = normalizeHandle(args.handle);
+
+  if (them === me) {
+    return { display: "You can't write a poem with yourself. Invite someone: `vibe poem @handle`." };
+  }
+
+  const thread = await store.getThread(me, them);
+  let state = getPoemState(thread);
+
+  // No line provided → show the current poem (or start a fresh one).
+  if (!line) {
+    if (!state) {
+      const newState = { lines: [], title: title || null, done: false, startedBy: me };
+      await store.sendMessage(
+        me,
+        them,
+        `Let's write an emoji poem together 📜 Add a line: \`vibe poem @${me} --line "…"\``,
+        'dm',
+        { type: 'poem', state: newState }
+      );
+      return {
+        display:
+          `## New emoji poem with @${them}\n\n${renderPoem(newState)}\n` +
+          `Add the first line: \`vibe poem @${them} --line "🌱 a small green start"\``,
+      };
+    }
+
+    // Show existing poem.
+    const authors = uniqueAuthors(state.lines);
+    let display = `## emoji poem with @${them}\n\n${renderPoem(state)}\n`;
+    if (state.done) {
+      display += `\n✨ Finished. Start another: \`vibe poem @${them} --line "…"\``;
+    } else if (isMyTurn(state, me)) {
+      display += `\nYour turn — add a line: \`vibe poem @${them} --line "…"\``;
+    } else {
+      display += `\nWaiting for @${them} to add the next line…`;
+    }
+    return { display };
+  }
+
+  // Adding a line.
+  if (!state) {
+    state = { lines: [], title: title || null, done: false, startedBy: me };
+  }
+
+  if (state.done) {
+    return {
+      display: `This poem is finished. Start a new one: \`vibe poem @${them} --line "…"\``,
+    };
+  }
+
+  if (!isMyTurn(state, me)) {
+    return {
+      display:
+        `It's @${them}'s turn to add a line.\n\n${renderPoem(state)}\n` +
+        `Nudge them, or wait for their line.`,
+    };
+  }
+
+  const text = String(line).trim();
+  if (!text) return { display: 'Give me a line to add: `vibe poem @handle --line "…"`' };
+  if (text.length > 200) return { display: 'Keep each line under 200 characters.' };
+
+  const newLines = [...(state.lines || []), { author: me, text }];
+  const shouldSeal = done === true || newLines.length >= MAX_LINES;
+  const newState = {
+    ...state,
+    lines: newLines,
+    done: shouldSeal,
+  };
+
+  const authors = uniqueAuthors(newLines);
+  let message;
+  if (shouldSeal) {
+    message = `Added a line and sealed our poem 📜✨\n\n${newLines.map((l) => l.text).join('\n')}`;
+    if (authors.length > 1) postPoemToBoard(newState, authors);
+  } else if (isMyTurn(newState, them)) {
+    message = `Added a line — your turn 📜\n"${text}"`;
+  } else {
+    message = `Added a line 📜\n"${text}"`;
+  }
+
+  await store.sendMessage(me, them, message, 'dm', { type: 'poem', state: newState });
+
+  let display = `## emoji poem with @${them}\n\n${renderPoem(newState)}\n`;
+  if (shouldSeal) {
+    display += `\n✨ Poem sealed${newLines.length >= MAX_LINES ? ` (${MAX_LINES} lines)` : ''}. Start another anytime.`;
+  } else {
+    display += `\nSent to @${them}. Waiting for their line…`;
+  }
+  return { display };
+}
+
+module.exports = { definition, handler };

package/version.json

@@ -1,11 +1,11 @@
 {
-  "version": "0.5.6",
-  "updated": "2026-06-30",
-  "changelog": "Come back to what you missed. Returning to /vibe now shows your unread count right away, and if we don't have an email to reach you at, we offer to arm the return-loop ping at the moment it matters — when a DM just landed while you were away.",
+  "version": "0.5.9",
+  "updated": "2026-07-03",
+  "changelog": "New way to play together: the exquisite corpse. `vibe_corpse @handle` starts a surrealist story you build one line at a time — but you only ever see the LAST line, never the whole thing, until someone seals it and the full corpse is revealed. Joins `vibe_game` (tic-tac-toe) and `vibe_poem` (emoji poem) as shared experiences carried over your DM thread. Ship together, play together.",
   "features": [
-    "Returning 'already signed in' surface now shows your unread count instead of a static line",
-    "Contextual email nudge on return: if a DM landed while you were away and we can't reach you, we offer 'vibe email' right then",
-    "One-line, offline-only, one-click unsubscribe — the return loop only pings when you're actually gone"
+    "vibe_corpse — write an exquisite corpse with another viber: alternate lines blind to all but the last, then seal for the big reveal",
+    "vibe_game — play tic-tac-toe with another viber, move by move, carried over your DM thread",
+    "vibe_poem — build a collaborative emoji poem together, one line each, until someone seals it"
   ],
   "deprecated": [
     "vibe_pair — use Matrix room invites",