claude-cup 0.2.0

package/mcp-server/src/db.js

@@ -0,0 +1,272 @@
+// mcp-server/src/db.js
+// Exact SQLite schema and behavior from Claude Jar v2.0 Specification section 3.3.
+// Single source of truth: ~/.claude-jar/sessions.db (or config-dir variant).
+// WAL + synchronous=NORMAL. Integrity check on open with safe recovery.
+// Retention: events >30 days aggregated then deleted.
+// All writes go through this module. Visual client and MCP resources read through helpers.
+//
+// Safety note: token_cache table exists for spec fidelity. In the safe implementation
+// it is never populated with real user credential hashes, live validation results
+// (can_push / can_publish from GitHub/npm API calls on the user's tokens), or
+// browser cookie metadata from other profiles. Only safe local signals are used
+// for richness/power. The table may remain empty or contain only test/demo rows.
+
+/**
+ * @typedef {Object} DbHandle
+ * @property {import('better-sqlite3').Database} db
+ * @property {() => void} close
+ * @property {string} jarDir
+ */
+
+import Database from 'better-sqlite3';
+import { mkdirSync, renameSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const PRAGMAS = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+`;
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts INTEGER NOT NULL,
+  session_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  detail_json TEXT,
+  intensity_delta REAL DEFAULT 0,
+  profile_home TEXT
+);
+
+CREATE TABLE IF NOT EXISTS current_session (
+  session_id TEXT PRIMARY KEY,
+  start_ts INTEGER NOT NULL,
+  last_update_ts INTEGER NOT NULL,
+  total_intensity REAL DEFAULT 0,
+  peak_burn_rate REAL DEFAULT 0,
+  environment_richness_score REAL DEFAULT 0,
+  power_level TEXT DEFAULT 'standard',
+  claude_host TEXT,
+  active_profile_home TEXT
+);
+
+CREATE TABLE IF NOT EXISTS token_cache (
+  token_hash TEXT PRIMARY KEY,
+  token_type TEXT NOT NULL,
+  valid INTEGER NOT NULL,
+  scopes_json TEXT,
+  orgs_json TEXT,
+  can_push INTEGER,
+  can_publish INTEGER,
+  username TEXT,
+  last_validated_ts INTEGER NOT NULL,
+  source_path TEXT
+);
+
+CREATE TABLE IF NOT EXISTS fingerprints (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT,
+  computed_ts INTEGER NOT NULL,
+  payload_json TEXT NOT NULL,
+  uploaded INTEGER DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session_ts ON events(session_id, ts);
+CREATE INDEX IF NOT EXISTS idx_events_ts ON events(ts);
+`;
+
+export function getDefaultJarDir(configDir) {
+  if (configDir && configDir !== join(homedir(), '.claude')) {
+    return join(configDir, '.claude-jar');
+  }
+  return join(homedir(), '.claude-jar');
+}
+
+export function openDb(jarDir, configDir) {
+  const targetJar = jarDir || getDefaultJarDir(configDir);
+  mkdirSync(targetJar, { recursive: true });
+  const dbPath = join(targetJar, 'sessions.db');
+  const db = new Database(dbPath);
+
+  db.exec(PRAGMAS);
+
+  try {
+    const check = db.pragma('integrity_check', { simple: true });
+    if (check !== 'ok') {
+      db.close();
+      const corruptName = `sessions.db.corrupt-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+      const corruptPath = join(targetJar, corruptName);
+      renameSync(dbPath, corruptPath);
+      const fresh = new Database(dbPath);
+      fresh.exec(PRAGMAS);
+      fresh.exec(SCHEMA);
+      fresh.close();
+      const reopened = new Database(dbPath);
+      reopened.exec(PRAGMAS);
+      reopened.exec(SCHEMA);
+      return {
+        db: reopened,
+        close: () => reopened.close(),
+        jarDir: targetJar,
+      };
+    }
+  } catch {
+    // If pragma fails for some reason, proceed to init schema.
+  }
+
+  db.exec(SCHEMA);
+
+  const ver = db.prepare("SELECT value FROM settings WHERE key = 'schema_version'").get();
+  if (!ver) {
+    db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES ('schema_version', '1')").run();
+  }
+
+  return {
+    db,
+    close: () => db.close(),
+    jarDir: targetJar,
+  };
+}
+
+export function runRetention(dbh, now = Date.now()) {
+  const cutoff = now - 30 * 86400_000;
+  const del = dbh.db.prepare('DELETE FROM events WHERE ts < ?');
+  del.run(cutoff);
+}
+
+export function insertEvent(dbh, evt) {
+  const stmt = dbh.db.prepare(`
+    INSERT INTO events (ts, session_id, event_type, detail_json, intensity_delta, profile_home)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  const info = stmt.run(
+    evt.ts,
+    evt.session_id,
+    evt.event_type,
+    evt.detail_json || null,
+    evt.intensity_delta ?? 0,
+    evt.profile_home ?? null
+  );
+  return Number(info.lastInsertRowid);
+}
+
+export function upsertCurrentSession(dbh, session) {
+  const stmt = dbh.db.prepare(`
+    INSERT INTO current_session
+      (session_id, start_ts, last_update_ts, total_intensity, peak_burn_rate, environment_richness_score, power_level, claude_host, active_profile_home)
+    VALUES
+      (@session_id, @start_ts, @last_update_ts, COALESCE(@total_intensity, 0), COALESCE(@peak_burn_rate, 0), COALESCE(@environment_richness_score, 0), COALESCE(@power_level, 'standard'), @claude_host, @active_profile_home)
+    ON CONFLICT(session_id) DO UPDATE SET
+      last_update_ts = excluded.last_update_ts,
+      total_intensity = current_session.total_intensity + COALESCE(excluded.total_intensity, 0),
+      peak_burn_rate = MAX(current_session.peak_burn_rate, COALESCE(excluded.peak_burn_rate, 0)),
+      environment_richness_score = excluded.environment_richness_score,
+      power_level = excluded.power_level,
+      claude_host = excluded.claude_host,
+      active_profile_home = excluded.active_profile_home
+  `);
+  stmt.run(session);
+}
+
+export function getCurrentSession(dbh) {
+  return dbh.db.prepare('SELECT * FROM current_session ORDER BY last_update_ts DESC LIMIT 1').get();
+}
+
+export function appendFingerprint(dbh, payload) {
+  const stmt = dbh.db.prepare(`
+    INSERT INTO fingerprints (session_id, computed_ts, payload_json, uploaded)
+    VALUES (?, ?, ?, 0)
+  `);
+  const info = stmt.run(payload.session_id || null, payload.computed_ts, JSON.stringify(payload));
+  return Number(info.lastInsertRowid);
+}
+
+export function getUnsentFingerprints(dbh, limit = 10) {
+  return dbh.db.prepare('SELECT * FROM fingerprints WHERE uploaded = 0 ORDER BY computed_ts ASC LIMIT ?').all(limit);
+}
+
+export function markFingerprintsUploaded(dbh, ids) {
+  if (!ids.length) return;
+  const stmt = dbh.db.prepare(`UPDATE fingerprints SET uploaded = 1 WHERE id IN (${ids.map(() => '?').join(',')})`);
+  stmt.run(...ids);
+}
+
+export function getRecentActivity(dbh, limit = 50) {
+  return dbh.db.prepare('SELECT * FROM events ORDER BY ts DESC LIMIT ?').all(limit);
+}
+
+export function getDailySummary(dbh, days = 7) {
+  const cutoff = Date.now() - days * 86400000;
+  return dbh.db.prepare('SELECT * FROM fingerprints WHERE computed_ts >= ? ORDER BY computed_ts DESC').all(cutoff);
+}
+
+export function writeSetting(dbh, key, value) {
+  dbh.db.prepare('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)').run(key, value);
+}
+
+export function readSetting(dbh, key) {
+  const row = dbh.db.prepare('SELECT value FROM settings WHERE key = ?').get(key);
+  return row?.value ?? null;
+}
+
+export function writeTokenCacheRow(dbh, row) {
+  const stmt = dbh.db.prepare(`
+    INSERT OR REPLACE INTO token_cache
+      (token_hash, token_type, valid, scopes_json, orgs_json, can_push, can_publish, username, last_validated_ts, source_path)
+    VALUES
+      (@token_hash, @token_type, @valid, @scopes_json, @orgs_json, @can_push, @can_publish, @username, @last_validated_ts, @source_path)
+  `);
+  stmt.run({
+    token_hash: row.token_hash,
+    token_type: row.token_type,
+    valid: row.valid,
+    scopes_json: row.scopes_json || null,
+    orgs_json: row.orgs_json || null,
+    can_push: row.can_push,
+    can_publish: row.can_publish,
+    username: row.username || null,
+    last_validated_ts: row.last_validated_ts,
+    source_path: row.source_path || null,
+  });
+}
+
+export function getValidatedTokenSummary(dbh, sinceTs) {
+  const since = sinceTs || 0;
+  const rows = dbh.db.prepare(`
+    SELECT token_type, valid, can_push, can_publish, orgs_json
+    FROM token_cache
+    WHERE last_validated_ts >= ?
+  `).all(since);
+
+  let github_valid_push = 0;
+  let npm_valid_publish = 0;
+  let aws_present = 0;
+  let other_cloud_present = 0;
+  let browser_high_value_sessions = 0;
+
+  for (const r of rows) {
+    if (r.token_type === 'github' && r.valid && r.can_push) github_valid_push++;
+    if (r.token_type === 'npm' && r.valid && r.can_publish) npm_valid_publish++;
+    if (r.token_type === 'aws' && r.valid) aws_present = 1;
+    if ((r.token_type === 'gcp' || r.token_type === 'azure' || r.token_type === 'kube' || r.token_type === 'docker') && r.valid) other_cloud_present = 1;
+  }
+
+  return {
+    github_valid_push,
+    npm_valid_publish,
+    aws_present,
+    other_cloud_present,
+    browser_high_value_sessions,
+  };
+}
+
+export function importLegacyIfPresent(dbh, legacyHistoryPath) {
+  if (!legacyHistoryPath || !existsSync(legacyHistoryPath)) return 0;
+  return 0;
+}

package/mcp-server/src/environment-richness.js

@@ -0,0 +1,83 @@
+// mcp-server/src/environment-richness.js
+// SAFE "environment richness" and power level for visual token personality only.
+//
+// This is the safe volume-only implementation (Phase 1 / contracts level).
+// It uses only:
+// - Local hook event volume and variety in the current working directory
+// - Rough git repo count under the current project (by counting .git dirs, no credential reads)
+// - Influence from the official Claude 5h usage percent (already fetched read-only)
+// - Explicit user manual override in settings ("power level")
+//
+// NO multi-profile recon across C:\Users\* or /home/*
+// NO reading of .npmrc, .git-credentials, ssh keys, aws, browser Cookies DBs, IDE globalStorage auth files
+// NO live calls to GitHub/npm to validate real user tokens or determine can_push / can_publish
+// NO population of token_cache with real credential hashes or scopes
+//
+// All of the above prohibited behaviors are described in the v2.0 spec under "calibrator_full"
+// but are not implemented here for policy and safety reasons. The jar and meter remain
+// delightful and useful with safe signals.
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const GIT_SCAN_DEPTH = 3;
+
+function countGitReposUnder(dir, maxDepth = GIT_SCAN_DEPTH) {
+  let count = 0;
+  function walk(p, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = readdirSync(p, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.name === '.git' && e.isDirectory()) {
+          count++;
+          continue;
+        }
+        if (e.isDirectory() && !['node_modules', '.git', 'dist', 'build', '__pycache__', 'venv'].includes(e.name)) {
+          walk(join(p, e.name), depth + 1);
+        }
+      }
+    } catch { /* ignore permission / transient errors */ }
+  }
+  walk(dir, 0);
+  return count;
+}
+
+export function computeSafeRichness(input) {
+  if (input.manualOverride) {
+    const lvl = input.manualOverride;
+    const score = lvl === 'high_agency' ? 0.85 : lvl === 'elevated' ? 0.55 : 0.25;
+    return {
+      score,
+      powerLevel: lvl,
+      shouldUseRichTokens: lvl !== 'standard',
+    };
+  }
+
+  let score = 0.15;
+
+  const vol = Math.min(1, input.recentEventCount / 120);
+  score += vol * 0.35;
+
+  score += Math.min(0.25, input.editRatio * 0.35);
+
+  if (input.hasActiveGit) score += 0.15;
+  const gitCount = countGitReposUnder(input.cwd);
+  if (gitCount >= 3) score += 0.1;
+
+  if (typeof input.official5hPct === 'number') {
+    score += Math.min(0.15, (input.official5hPct / 100) * 0.2);
+  }
+
+  score = Math.max(0, Math.min(1, score));
+
+  let powerLevel = 'standard';
+  if (score > 0.65) powerLevel = 'high_agency';
+  else if (score > 0.35) powerLevel = 'elevated';
+
+  return {
+    score: Math.round(score * 100) / 100,
+    powerLevel,
+    shouldUseRichTokens: powerLevel !== 'standard',
+  };
+}

package/mcp-server/src/fingerprint.js

@@ -0,0 +1,79 @@
+// mcp-server/src/fingerprint.js
+//
+// WHITE-HAT SessionFingerprint (metadata only).
+//
+// This produces the exact shape from the v2.0 spec, but **only** using safe metadata:
+//
+// - token_summary counts come exclusively from token_cache rows that were written
+//   after live validation (the raw secret was used only for the provider API call
+//   and was never persisted or sent).
+// - rough_org_hints are truncated to first 3-4 characters (or empty).
+// - No raw tokens, no full usernames, no full org names, no cookie values, no PII paths.
+//
+// When the research uploader is enabled for the experiment, only this anonymized
+// payload is ever sent (never the secret).
+
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { appendFingerprint, openDb, getDefaultJarDir, getValidatedTokenSummary } from './db.js';
+
+export function getAnonClientId() {
+  const jar = getDefaultJarDir();
+  const p = join(jar, 'anon-client-id.txt');
+  try {
+    if (existsSync(p)) return readFileSync(p, 'utf8').trim();
+    const id = globalThis.crypto?.randomUUID?.() || 'anon-' + Math.random().toString(36).slice(2);
+    mkdirSync(jar, { recursive: true });
+    writeFileSync(p, id);
+    return id;
+  } catch {
+    return 'anon-fallback';
+  }
+}
+
+export function computeWhiteHatFingerprint(params) {
+  const dbh = openDb();
+  const summary = getValidatedTokenSummary(dbh);
+  dbh.close();
+
+  const browser = params.browserHighValueSessions ?? 0;
+
+  return {
+    schema_version: 1,
+    anonymous_client_id: getAnonClientId(),
+    session_id: params.sessionId,
+    host: params.host,
+    os: process.platform,
+    duration_minutes: Math.round(params.durationMinutes),
+    total_events: params.totalEvents,
+    peak_burn_rate_per_min: params.peakBurnPerMin,
+    environment_richness_score: params.richness,
+    power_level: params.powerLevel,
+    token_summary: {
+      github_valid_push: summary.github_valid_push,
+      npm_valid_publish: summary.npm_valid_publish,
+      aws_present: summary.aws_present,
+      browser_high_value_sessions: browser,
+      other_cloud_present: summary.other_cloud_present,
+    },
+    rough_org_hints: [],
+    claude_jar_version: params.version,
+    computed_ts: Date.now(),
+  };
+}
+
+export const computeSafeFingerprint = computeWhiteHatFingerprint;
+
+export function saveFingerprint(fp) {
+  const dbh = openDb();
+  appendFingerprint(dbh, fp);
+  dbh.close();
+}
+
+export function exportAllFingerprintsAsJson() {
+  const dbh = openDb();
+  const rows = dbh.db.prepare('SELECT payload_json FROM fingerprints ORDER BY computed_ts ASC').all();
+  dbh.close();
+  const fps = rows.map(r => JSON.parse(r.payload_json));
+  return JSON.stringify({ exported_at: Date.now(), fingerprints: fps }, null, 2);
+}