@fruition/fcp-mcp-server 1.20.0 → 1.22.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/dist/skills-sync.js

@@ -573,13 +573,45 @@ function emptyResult(dryRun) {
         dryRun,
     };
 }
+/**
+ * Decide whether this run should be a dry run, and persist auto-opt-in when
+ * appropriate. Returns the resolved `dryRun` boolean and mutates `state` to
+ * record auto-opt-in so subsequent runs don't re-log the upgrade banner.
+ *
+ * Precedence:
+ *  1. Explicit `opts.dryRun` always wins (tests, --dry-run flag, callers
+ *     that mean "I know what I'm doing").
+ *  2. Already opted in -> real run.
+ *  3. Proxy mode (FCP_API_TOKEN -> FCP proxy -> Unroo) -> auto-opt-in. Only
+ *     Fruition team members can mint an FCP API key, so reaching the proxy
+ *     is itself proof of team membership. Persist optedIn=true so we log the
+ *     auto-enable message exactly once.
+ *  4. Direct mode (personal UNROO_API_KEY) -> stay dry-run until the user
+ *     runs `fcp-mcp-server sync-skills --enable`. Direct mode is the
+ *     power-user / script path; we don't want to assume intent there.
+ */
+function resolveDryRun(opts, state, transport, log) {
+    if (opts.dryRun !== undefined)
+        return opts.dryRun;
+    if (state.optedIn === true)
+        return false;
+    if (transport.configured && transport.mode === 'proxy') {
+        state.optedIn = true;
+        log('[skills-sync] auto-enabled for Fruition team member ' +
+            '(reached via FCP proxy). Skills with name+description in ' +
+            'frontmatter will be pushed; scratch (_*, .*, digit-prefixed) ' +
+            'and private:true skills are skipped. To disable, delete ' +
+            '~/.claude/skills/.sync-state.json or set private:true.');
+        return false;
+    }
+    return true;
+}
 /** Push local skills up to Unroo. */
 export async function pushSkills(opts = {}) {
     const state = loadState(opts.stateFile ?? defaultStateFile(opts.skillsDir ?? defaultSkillsDir()));
-    // Fresh workstation -> force dry-run unless explicitly opted in OR caller
-    // passed dryRun:false meaning "I know what I'm doing".
-    const dryRun = opts.dryRun !== undefined ? opts.dryRun : state.optedIn !== true;
     const transport = resolveTransport(opts);
+    const log = opts.log ?? ((m) => console.error(m));
+    const dryRun = resolveDryRun(opts, state, transport, log);
     const ctx = makeCtx(opts, dryRun, transport);
     const result = emptyResult(dryRun);
     if (!transport.configured) {
@@ -595,8 +627,9 @@ export async function pushSkills(opts = {}) {
 /** Pull team skills from Unroo down to local. */
 export async function pullSkills(opts = {}) {
     const state = loadState(opts.stateFile ?? defaultStateFile(opts.skillsDir ?? defaultSkillsDir()));
-    const dryRun = opts.dryRun !== undefined ? opts.dryRun : state.optedIn !== true;
     const transport = resolveTransport(opts);
+    const log = opts.log ?? ((m) => console.error(m));
+    const dryRun = resolveDryRun(opts, state, transport, log);
     const ctx = makeCtx(opts, dryRun, transport);
     const result = emptyResult(dryRun);
     if (!transport.configured) {
@@ -612,8 +645,9 @@ export async function pullSkills(opts = {}) {
 /** Bidirectional sync: pull then push. */
 export async function syncSkills(opts = {}) {
     const state = loadState(opts.stateFile ?? defaultStateFile(opts.skillsDir ?? defaultSkillsDir()));
-    const dryRun = opts.dryRun !== undefined ? opts.dryRun : state.optedIn !== true;
     const transport = resolveTransport(opts);
+    const log = opts.log ?? ((m) => console.error(m));
+    const dryRun = resolveDryRun(opts, state, transport, log);
     const ctx = makeCtx(opts, dryRun, transport);
     const result = emptyResult(dryRun);
     if (!transport.configured) {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.20.0",
+  "version": "1.22.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",