@fruition/fcp-mcp-server 1.19.0 → 1.21.0

package/bin/unroo-heartbeat.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+// ============================================================================
+// UNROO CLAUDE CODE HEARTBEAT (Node version)
+// ============================================================================
+// Successor to unroo-heartbeat.sh. Reads Claude Code's hook stdin protocol
+// properly (the shell version had no way to parse hook JSON, so `tool_name`,
+// `transcript_path`, and `session_id` were never carried through).
+//
+// Wired into Claude Code via ~/.claude/settings.json hooks:
+//   PostToolUse * → unroo-heartbeat                 (per-turn token + skill delta)
+//   Stop          → unroo-heartbeat session_end     (final flush + session end)
+//
+// Per-turn delta design (the Unroo server expects this shape — see
+// src/lib/unroo/ai-productivity-capture.ts). For each NEW assistant turn
+// appended to the transcript since the last hook fired, we POST one
+// heartbeat carrying that turn's `primary_model`, token usage (as deltas —
+// the server uses Prisma `increment`), and any Skill tool invocations from
+// that turn (server upserts +1 per skill).
+//
+// Scratch state at ~/.claude/unroo-tracking/<cc_session_id>.json keeps a
+// line cursor into the transcript so we never double-count.
+//
+// Soft-fail everywhere — this MUST NOT block Claude Code, ever.
+//
+// Env:
+//   UNROO_API_KEY       Required. Without it, exit 0 silently.
+//   UNROO_API_ENDPOINT  Optional. Default https://app.unroo.io.
+// ============================================================================
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import https from 'node:https';
+import http from 'node:http';
+
+const API_KEY = process.env.UNROO_API_KEY;
+if (!API_KEY) process.exit(0); // No key set — silent no-op (matches old behaviour).
+
+const API_BASE = process.env.UNROO_API_ENDPOINT || 'https://app.unroo.io';
+const API_URL = `${API_BASE.replace(/\/$/, '')}/api/unroo/claude-tracker/heartbeat`;
+
+const SCRATCH_DIR = path.join(os.homedir(), '.claude', 'unroo-tracking');
+
+// ── stdin (Claude Code hook payload, JSON) ───────────────────────────────────
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve(null);
+    let data = '';
+    let settled = false;
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      try { resolve(data ? JSON.parse(data) : null); } catch { resolve(null); }
+    };
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', done);
+    process.stdin.on('error', () => done());
+    setTimeout(done, 800); // Safety — never block forever.
+  });
+}
+
+// ── small utility helpers ────────────────────────────────────────────────────
+
+function sh(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch { return ''; }
+}
+
+function machineId() {
+  try {
+    if (fs.existsSync('/etc/machine-id')) {
+      return fs.readFileSync('/etc/machine-id', 'utf8').trim().slice(0, 8);
+    }
+    if (fs.existsSync('/var/lib/dbus/machine-id')) {
+      return fs.readFileSync('/var/lib/dbus/machine-id', 'utf8').trim().slice(0, 8);
+    }
+    const ioreg = sh('ioreg -rd1 -c IOPlatformExpertDevice');
+    const m = ioreg.match(/IOPlatformUUID"\s*=\s*"([^"]+)"/);
+    if (m) return m[1].slice(0, 8);
+    return sh('hostid').slice(0, 8);
+  } catch { return ''; }
+}
+
+function projectSlugFromCwd() {
+  try {
+    if (!fs.existsSync('.unroo')) return '';
+    const text = fs.readFileSync('.unroo', 'utf8');
+    const m = text.match(/^project_slug=(.+)$/m);
+    return m ? m[1].trim() : '';
+  } catch { return ''; }
+}
+
+// ── scratch state (per Claude Code session_id) ───────────────────────────────
+
+function scratchPathFor(sessionId) {
+  if (!sessionId) return null;
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_.-]/g, '').slice(0, 80);
+  return path.join(SCRATCH_DIR, `${safe}.json`);
+}
+
+function readScratch(sessionId) {
+  const p = scratchPathFor(sessionId);
+  if (!p || !fs.existsSync(p)) return { last_line_index: 0 };
+  try {
+    const s = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return { last_line_index: Number(s.last_line_index) || 0 };
+  } catch {
+    return { last_line_index: 0 };
+  }
+}
+
+function writeScratch(sessionId, state) {
+  const p = scratchPathFor(sessionId);
+  if (!p) return;
+  try {
+    fs.mkdirSync(SCRATCH_DIR, { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(state));
+  } catch { /* best-effort */ }
+}
+
+function deleteScratch(sessionId) {
+  const p = scratchPathFor(sessionId);
+  if (!p) return;
+  try { fs.unlinkSync(p); } catch { /* missing-ok */ }
+}
+
+// ── transcript parsing — extract NEW assistant turns since `fromIndex` ───────
+
+/**
+ * Parse the transcript JSONL starting at `fromIndex`. Returns one entry per
+ * assistant message that carries a `message.usage` block, plus the new line
+ * cursor. Skills are extracted per-turn from `tool_use` blocks with name
+ * "Skill". Tokens come straight from the per-turn `usage`.
+ */
+function parseNewTurns(transcriptPath, fromIndex) {
+  const turns = [];
+  let newIndex = fromIndex;
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    return { turns, newIndex };
+  }
+
+  let buf;
+  try { buf = fs.readFileSync(transcriptPath, 'utf8'); } catch { return { turns, newIndex }; }
+  const lines = buf.split('\n');
+
+  for (let i = fromIndex; i < lines.length; i++) {
+    newIndex = i + 1;
+    const line = lines[i];
+    if (!line) continue;
+
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    const msg = row.message;
+    if (!msg || typeof msg !== 'object') continue;
+    if (!msg.usage || !msg.model) continue;
+
+    const skills = [];
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block && block.type === 'tool_use' && block.name === 'Skill') {
+          const input = block.input || {};
+          const slug = input.skill || input.name || null;
+          if (slug) skills.push({ slug: String(slug), name: String(slug), source: 'local' });
+        }
+      }
+    }
+
+    turns.push({
+      model: String(msg.model),
+      tokens_input: Number(msg.usage.input_tokens || 0) || 0,
+      tokens_output: Number(msg.usage.output_tokens || 0) || 0,
+      tokens_cache_read: Number(msg.usage.cache_read_input_tokens || 0) || 0,
+      tokens_cache_write: Number(msg.usage.cache_creation_input_tokens || 0) || 0,
+      skills,
+    });
+  }
+
+  return { turns, newIndex };
+}
+
+// ── HTTP POST (fire-and-forget, short timeout) ───────────────────────────────
+
+function postJson(payload) {
+  return new Promise((resolve) => {
+    let u;
+    try { u = new URL(API_URL); } catch { return resolve(); }
+    const lib = u.protocol === 'https:' ? https : http;
+    const body = JSON.stringify(payload);
+    const req = lib.request(
+      {
+        method: 'POST',
+        hostname: u.hostname,
+        port: u.port || (u.protocol === 'https:' ? 443 : 80),
+        path: `${u.pathname}${u.search || ''}`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        },
+        timeout: 3000,
+      },
+      (res) => {
+        res.resume();
+        res.on('end', () => resolve());
+        res.on('error', () => resolve());
+      },
+    );
+    req.on('error', () => resolve());
+    req.on('timeout', () => { req.destroy(); resolve(); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// ── main ─────────────────────────────────────────────────────────────────────
+
+(async () => {
+  const hook = await readStdin();
+  const argEvent = process.argv[2];
+  const hookEvent = hook && typeof hook.hook_event_name === 'string' ? hook.hook_event_name : null;
+
+  let eventType = argEvent || 'tool_end';
+  if (hookEvent === 'Stop' || hookEvent === 'SubagentStop') eventType = 'session_end';
+  else if (hookEvent === 'PostToolUse') eventType = 'tool_end';
+
+  const ccSessionId = (hook && hook.session_id) || null;
+  const transcriptPath = (hook && hook.transcript_path) || null;
+
+  const gitRemote = sh('git remote get-url origin');
+  const gitBranch = sh('git symbolic-ref --short HEAD');
+  const repoName = path.basename(process.cwd());
+
+  const baseFields = {
+    api_key: API_KEY,
+    source: 'claude-code',
+    git_remote_url: gitRemote || '',
+    git_branch: gitBranch || '',
+    repo_name: repoName,
+    machine_id: machineId(),
+    tool_name: (hook && hook.tool_name) || process.env.TOOL_NAME || '',
+    tool_description: process.env.TOOL_DESCRIPTION || '',
+    project_slug: projectSlugFromCwd(),
+    cc_session_id: ccSessionId,
+    actor_type: 'interactive_agent',
+  };
+
+  const scratch = readScratch(ccSessionId);
+  const { turns, newIndex } = parseNewTurns(transcriptPath, scratch.last_line_index);
+
+  // Persist the cursor before any POSTs so a crashed hook still moves forward
+  // (better to miss one turn than to double-count it on the next call).
+  writeScratch(ccSessionId, { last_line_index: newIndex });
+
+  // Each new assistant turn is posted as tool_end. The server's tool_end
+  // branch creates or updates the session row and accumulates the per-turn
+  // token delta + skills via mergeModelUsage / recordSkillInvocations.
+  //
+  // Sequential — NOT parallel — because the first POST of a brand-new
+  // session triggers auto-create of a claude_repo_mappings row; running
+  // them in parallel races the unique constraint on (org, git_remote_url)
+  // and one POST errors out. In practice each hook fire has 0-1 new turns
+  // so sequential is effectively the same speed.
+  for (const turn of turns) {
+    await postJson({
+      ...baseFields,
+      event_type: 'tool_end',
+      primary_model: turn.model,
+      tokens_input: turn.tokens_input,
+      tokens_output: turn.tokens_output,
+      tokens_cache_read: turn.tokens_cache_read,
+      tokens_cache_write: turn.tokens_cache_write,
+      skills_invoked: turn.skills,
+    });
+  }
+
+  if (eventType === 'session_end') {
+    // Stop / SubagentStop: the server's session_end branch only finalises
+    // an EXISTING session row. If no turns were processed in this hook fire
+    // and there's no prior tool_end on this user+repo+day, the row doesn't
+    // exist yet and session_end would no-op. Send a bare tool_end first to
+    // guarantee the session is created, then finalise.
+    if (turns.length === 0) {
+      await postJson({ ...baseFields, event_type: 'tool_end' });
+    }
+    await postJson({ ...baseFields, event_type: 'session_end' });
+  } else if (turns.length === 0) {
+    // PostToolUse with no new transcript content (e.g. multiple tool calls
+    // within the same assistant turn). One keepalive — the server records
+    // last_heartbeat_at and bumps total_tool_calls.
+    await postJson({ ...baseFields, event_type: eventType });
+  }
+
+  if (eventType === 'session_end') deleteScratch(ccSessionId);
+
+  process.exit(0);
+})().catch(() => process.exit(0));

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.19.0",
+  "version": "1.21.0",
   "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches and track development time",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
     "fcp-mcp-server": "./dist/index.js",
-    "unroo-heartbeat": "./bin/unroo-heartbeat.sh"
+    "unroo-heartbeat": "./bin/unroo-heartbeat.js"
   },
   "files": [
     "dist",

package/dist/index.d.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * FCP MCP Server
- *
- * Provides Claude Code with direct access to FCP Launch Coordination System:
- * - Query launches, checklists, and legacy access info
- * - Update checklist item status
- * - Get project context for migrations
- */
-export {};