@kylindc/ccxray 1.2.0

package/server/sse-broadcast.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const store = require('./store');
+
+// Strip req/res from broadcast — browser only needs summary for the turn list
+function summarizeEntry(entry) {
+  const tok = entry.tokens;
+  return {
+    id: entry.id, ts: entry.ts, sessionId: entry.sessionId,
+    method: entry.method, url: entry.url,
+    elapsed: entry.elapsed, status: entry.status, isSSE: entry.isSSE,
+    usage: entry.usage, cost: entry.cost, maxContext: entry.maxContext, cwd: entry.cwd,
+    model: entry.model || null,
+    msgCount: entry.msgCount || 0,
+    toolCount: entry.toolCount || 0,
+    toolCalls: entry.toolCalls || [],
+    isSubagent: entry.isSubagent || false,
+    title: entry.title || null,
+    stopReason: entry.stopReason || '',
+    thinkingDuration: entry.thinkingDuration || null,
+    duplicateToolCalls: entry.duplicateToolCalls || null,
+    tokens: tok ? {
+      system: tok.system, tools: tok.tools, messages: tok.messages, total: tok.total,
+      contextBreakdown: tok.contextBreakdown,
+      perMessage: tok.perMessage || null,
+    } : null,
+  };
+}
+
+function broadcast(entry) {
+  const data = JSON.stringify(summarizeEntry(entry));
+  for (const res of store.sseClients) {
+    res.write(`data: ${data}\n\n`);
+  }
+}
+
+function broadcastSessionStatus(sessionId) {
+  const active = (store.activeRequests[sessionId] || 0) > 0;
+  const lastSeenAt = store.sessionMeta[sessionId]?.lastSeenAt || null;
+  const data = JSON.stringify({ _type: 'session_status', sessionId, active, lastSeenAt });
+  for (const res of store.sseClients) {
+    res.write(`data: ${data}\n\n`);
+  }
+}
+
+function broadcastPendingRequest(requestId, parsedBody, sessionId) {
+  const data = JSON.stringify({
+    _type: 'pending_request', requestId, sessionId,
+    body: parsedBody,
+  });
+  for (const res of store.sseClients) res.write(`data: ${data}\n\n`);
+}
+
+function broadcastInterceptToggle(sessionId, enabled) {
+  const data = JSON.stringify({ _type: 'intercept_toggled', sessionId, enabled });
+  for (const res of store.sseClients) res.write(`data: ${data}\n\n`);
+}
+
+function broadcastInterceptRemoved(requestId) {
+  const data = JSON.stringify({ _type: 'intercept_removed', requestId });
+  for (const res of store.sseClients) res.write(`data: ${data}\n\n`);
+}
+
+module.exports = {
+  summarizeEntry,
+  broadcast,
+  broadcastSessionStatus,
+  broadcastPendingRequest,
+  broadcastInterceptToggle,
+  broadcastInterceptRemoved,
+};

package/server/storage/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { createLocalStorage } = require('./local');
+
+/**
+ * Create the appropriate storage adapter based on STORAGE_BACKEND env var.
+ *
+ * STORAGE_BACKEND=local (default) — local filesystem
+ * STORAGE_BACKEND=s3 — S3/R2 (requires @aws-sdk/client-s3)
+ *
+ * @returns {import('./interface').StorageAdapter}
+ */
+function createStorage() {
+  const backend = (process.env.STORAGE_BACKEND || 'local').toLowerCase();
+
+  switch (backend) {
+    case 's3': {
+      const { createS3Storage } = require('./s3');
+      return createS3Storage({
+        bucket: process.env.S3_BUCKET,
+        region: process.env.S3_REGION || 'auto',
+        endpoint: process.env.S3_ENDPOINT || undefined,
+        prefix: process.env.S3_PREFIX || 'logs/',
+      });
+    }
+    case 'local':
+    default: {
+      const path = require('path');
+      const os = require('os');
+      const logsDir = process.env.LOGS_DIR || path.join(process.env.CCXRAY_HOME || path.join(os.homedir(), '.ccxray'), 'logs');
+      return createLocalStorage(logsDir);
+    }
+  }
+}
+
+module.exports = { createStorage };

package/server/storage/interface.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+ * Storage adapter interface for ccxray log persistence.
+ *
+ * Every adapter must implement these methods. The proxy uses `id` (timestamp-based)
+ * and `suffix` (_req.json, _res.json, _sse.txt) to identify files.
+ *
+ * @typedef {Object} StorageAdapter
+ * @property {() => Promise<void>} init
+ *   Ensure storage backend is ready (create dirs, check credentials, etc.).
+ *
+ * @property {(id: string, suffix: string, data: string|Buffer) => Promise<void>} write
+ *   Write a log artifact. Fire-and-forget callers should .catch() the promise.
+ *
+ * @property {(id: string, suffix: string) => Promise<string>} read
+ *   Read a log artifact as UTF-8 string. Throws if not found.
+ *
+ * @property {() => Promise<string[]>} list
+ *   List all filenames in the log store (e.g. ['2025-03-17T12-00-00-000_req.json', ...]).
+ *
+ * @property {(id: string, suffix: string) => Promise<{mtimeMs: number}>} stat
+ *   Get metadata (at minimum mtimeMs) for a log artifact. Throws if not found.
+ */
+
+module.exports = {};

package/server/storage/local.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+const fsp = fs.promises;
+const path = require('path');
+
+/**
+ * Local filesystem storage adapter.
+ * @param {string} logsDir — absolute path to the logs directory
+ * @returns {import('./interface').StorageAdapter}
+ */
+function createLocalStorage(logsDir) {
+  const sharedDir = path.join(logsDir, 'shared');
+  const indexPath = path.join(logsDir, 'index.ndjson');
+
+  return {
+    async init() {
+      await fsp.mkdir(logsDir, { recursive: true });
+      await fsp.mkdir(sharedDir, { recursive: true });
+    },
+
+    async write(id, suffix, data) {
+      await fsp.writeFile(path.join(logsDir, id + suffix), data);
+    },
+
+    async read(id, suffix) {
+      return fsp.readFile(path.join(logsDir, id + suffix), 'utf8');
+    },
+
+    async list() {
+      return fsp.readdir(logsDir);
+    },
+
+    async stat(id, suffix) {
+      return fsp.stat(path.join(logsDir, id + suffix));
+    },
+
+    // ── Index (index.ndjson) ──────────────────────────────────────────
+
+    async appendIndex(line) {
+      await fsp.appendFile(indexPath, line);
+    },
+
+    async readIndex() {
+      try {
+        return await fsp.readFile(indexPath, 'utf8');
+      } catch (e) {
+        if (e.code === 'ENOENT') return '';
+        throw e;
+      }
+    },
+
+    // ── Shared content-addressed storage (shared/) ───────────────────
+
+    async writeSharedIfAbsent(filename, data) {
+      const p = path.join(sharedDir, filename);
+      try {
+        await fsp.writeFile(p, data, { flag: 'wx' });
+      } catch (e) {
+        if (e.code !== 'EEXIST') throw e;
+      }
+    },
+
+    async readShared(filename) {
+      return fsp.readFile(path.join(sharedDir, filename), 'utf8');
+    },
+
+    async listShared() {
+      try {
+        return await fsp.readdir(sharedDir);
+      } catch (e) {
+        if (e.code === 'ENOENT') return [];
+        throw e;
+      }
+    },
+  };
+}
+
+module.exports = { createLocalStorage };

package/server/storage/s3.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * S3/R2 storage adapter skeleton.
+ *
+ * Requires: @aws-sdk/client-s3 (or compatible R2 endpoint).
+ * Configure via environment variables:
+ *   S3_BUCKET, S3_REGION, S3_ENDPOINT (for R2/MinIO), S3_PREFIX
+ *
+ * @param {Object} opts
+ * @param {string} opts.bucket
+ * @param {string} [opts.region='auto']
+ * @param {string} [opts.endpoint]
+ * @param {string} [opts.prefix='logs/']
+ * @returns {import('./interface').StorageAdapter}
+ */
+function createS3Storage(opts) {
+  const { bucket, region = 'auto', endpoint, prefix = 'logs/' } = opts;
+
+  // Lazy-load SDK to avoid hard dependency
+  let s3;
+  function getClient() {
+    if (s3) return s3;
+    const { S3Client } = require('@aws-sdk/client-s3');
+    s3 = new S3Client({
+      region,
+      ...(endpoint ? { endpoint, forcePathStyle: true } : {}),
+    });
+    return s3;
+  }
+
+  function key(id, suffix) {
+    return prefix + id + suffix;
+  }
+
+  return {
+    async init() {
+      // Verify bucket access
+      const { HeadBucketCommand } = require('@aws-sdk/client-s3');
+      await getClient().send(new HeadBucketCommand({ Bucket: bucket }));
+    },
+
+    async write(id, suffix, data) {
+      const { PutObjectCommand } = require('@aws-sdk/client-s3');
+      await getClient().send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: key(id, suffix),
+        Body: data,
+        ContentType: suffix.endsWith('.json') ? 'application/json' : 'text/plain',
+      }));
+    },
+
+    async read(id, suffix) {
+      const { GetObjectCommand } = require('@aws-sdk/client-s3');
+      const res = await getClient().send(new GetObjectCommand({
+        Bucket: bucket,
+        Key: key(id, suffix),
+      }));
+      return res.Body.transformToString('utf-8');
+    },
+
+    async list() {
+      const { ListObjectsV2Command } = require('@aws-sdk/client-s3');
+      const files = [];
+      let token;
+      do {
+        const res = await getClient().send(new ListObjectsV2Command({
+          Bucket: bucket,
+          Prefix: prefix,
+          ContinuationToken: token,
+        }));
+        for (const obj of (res.Contents || [])) {
+          files.push(obj.Key.slice(prefix.length));
+        }
+        token = res.IsTruncated ? res.NextContinuationToken : null;
+      } while (token);
+      return files;
+    },
+
+    async stat(id, suffix) {
+      const { HeadObjectCommand } = require('@aws-sdk/client-s3');
+      const res = await getClient().send(new HeadObjectCommand({
+        Bucket: bucket,
+        Key: key(id, suffix),
+      }));
+      return { mtimeMs: res.LastModified ? res.LastModified.getTime() : Date.now() };
+    },
+  };
+}
+
+module.exports = { createS3Storage };

package/server/store.js

@@ -0,0 +1,108 @@
+'use strict';
+
+// ── In-memory store & SSE clients ───────────────────────────────────
+const MAX_ENTRIES = parseInt(process.env.CCXRAY_MAX_ENTRIES || '5000', 10);
+const entries = [];
+const sseClients = [];
+
+function trimEntries() {
+  if (entries.length > MAX_ENTRIES) {
+    entries.splice(0, entries.length - MAX_ENTRIES);
+  }
+}
+
+// ── Rate limit state (from Anthropic response headers) ──────────────
+let rateLimitState = null;
+
+// ── Session tracking ────────────────────────────────────────────────
+let currentSessionId = null;
+let lastMsgCount = 0;
+let sessionCounter = 0;
+
+// ── Session metadata (cwd per session) ──────────────────────────────
+const sessionMeta = {}; // { sessionId: { cwd, lastSeenAt } }
+const activeRequests = {}; // sessionId → in-flight count
+const sessionCosts = new Map(); // sessionId → accumulated cost
+
+// ── Version Index (cc_version → { reqId, b2Len, firstSeen }) ────────
+const versionIndex = new Map();
+
+// ── Intercept (request pause) ────────────────────────────────────────
+const interceptSessions = new Set();
+const pendingRequests = new Map();
+let interceptTimeout = 120;
+
+function isQuotaCheck(req) {
+  return req?.max_tokens === 1 && !req?.system &&
+    req?.messages?.length === 1 && req.messages[0]?.content === 'quota';
+}
+
+function extractCwd(req) {
+  if (isQuotaCheck(req)) return '(quota-check)';
+  if (!req?.system) return null;
+  const txt = Array.isArray(req.system) ? req.system.map(b => b.text || '').join('\n') : String(req.system);
+  const m = txt.match(/Primary working directory: (.+)/);
+  return m ? m[1].trim() : null;
+}
+
+function extractSessionId(req) {
+  const uid = req?.metadata?.user_id || '';
+  // New format: user_id is JSON like {"session_id":"xxx-yyy"}
+  const jsonMatch = uid.match(/"session_id"\s*:\s*"([a-f0-9-]+)"/);
+  if (jsonMatch) return jsonMatch[1];
+  // Legacy format: user_id is "session_xxx-yyy"
+  const m = uid.match(/session_([a-f0-9-]+)/);
+  return m ? m[1] : null;
+}
+
+function detectSession(req) {
+  const realId = extractSessionId(req);
+  const isNew = realId ? (realId !== currentSessionId) : (!currentSessionId || (req?.messages?.length || 0) < lastMsgCount);
+  if (isNew) {
+    sessionCounter++;
+    currentSessionId = realId || 'direct-api';
+  }
+  lastMsgCount = req?.messages?.length || 0;
+  return { sessionId: currentSessionId, isNewSession: isNew };
+}
+
+function printSessionBanner(sessionId) {
+  const w = 60;
+  const shortId = sessionId.slice(0, 8);
+  const label = ` NEW SESSION ${shortId} `;
+  const pad = Math.max(0, Math.floor((w - label.length) / 2));
+  const line = '★'.repeat(pad) + label + '★'.repeat(w - pad - label.length);
+  console.log();
+  console.log('\x1b[1;35m' + line + '\x1b[0m');
+  console.log(`\x1b[35m   claude --continue ${sessionId}\x1b[0m`);
+  console.log();
+}
+
+function getRateLimitState() { return rateLimitState; }
+function setRateLimitState(state) { rateLimitState = state; }
+function getInterceptTimeout() { return interceptTimeout; }
+function setInterceptTimeout(val) { interceptTimeout = val; }
+function getCurrentSessionId() { return currentSessionId; }
+
+module.exports = {
+  MAX_ENTRIES,
+  entries,
+  trimEntries,
+  sseClients,
+  getRateLimitState,
+  setRateLimitState,
+  sessionMeta,
+  activeRequests,
+  sessionCosts,
+  versionIndex,
+  interceptSessions,
+  pendingRequests,
+  getInterceptTimeout,
+  setInterceptTimeout,
+  getCurrentSessionId,
+  isQuotaCheck,
+  extractCwd,
+  extractSessionId,
+  detectSession,
+  printSessionBanner,
+};

package/server/system-prompt.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const { safeCountTokens } = require('./helpers');
+
+// ── System prompt diff helpers ───────────────────────────────────────
+
+const BLOCK_OWNERS_SERVER = {
+  billingHeader: 'anthropic', coreIdentity: 'anthropic', coreInstructions: 'anthropic',
+  customSkills: 'user', pluginSkills: 'user', mcpServersList: 'user', settingsJson: 'user', envAndGit: 'user',
+  customAgents: 'user', autoMemory: 'user',
+};
+
+function extractAgentType(sys) {
+  if (!Array.isArray(sys) || sys.length < 2) return { key: 'unknown', label: 'Unknown' };
+  const b1 = (sys[1]?.text || '').trim();
+  const b2 = (sys[2]?.text || '').trim();
+  // Primary: main Claude Code prompt
+  if (b2.startsWith('You are an interactive agent')) return { key: 'claude-code', label: 'Claude Code' };
+  // Known sub-agents by b2 content (must come before b1 fallback — sub-agents also have b1="You are Claude Code")
+  if (b2.startsWith('Generate a concise')) return { key: 'title-generator', label: 'Title Generator' };
+  // Fallback: older versions put the identity in b1
+  if (b1.startsWith('You are Claude Code')) return { key: 'claude-code', label: 'Claude Code' };
+  // "You are a/an/the <role>" pattern
+  const m = b2.match(/^You are (?:a |an |the )?(.+?)(?:\s+for\s|\s+that\s|\s+specializ|\s*[,.]|\n)/i);
+  if (m) {
+    const role = m[1].trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '').slice(0, 40);
+    const label = m[1].trim().replace(/\b\w/g, c => c.toUpperCase());
+    return { key: role || 'agent', label: label || 'Agent' };
+  }
+  return { key: 'agent', label: 'Agent' };
+}
+
+function splitB2IntoBlocks(b2) {
+  const markerDefs = [
+    { key: 'customSkills',   pattern: /# User'?s Current Configuration/ },
+    { key: 'customAgents',   pattern: /\*\*Available custom agents/ },
+    { key: 'mcpServersList', pattern: /\*\*Configured MCP servers/ },
+    { key: 'pluginSkills',   pattern: /\*\*Available plugin skills/ },
+    { key: 'settingsJson',   pattern: /\*\*User's settings\.json/ },
+    { key: 'envAndGit',      pattern: /# Environment\n|<env>/ },
+    { key: 'autoMemory',     pattern: /# auto memory\n|You have a persistent, file-based memory/ },
+  ];
+  const positions = [];
+  for (const m of markerDefs) {
+    const match = m.pattern.exec(b2);
+    if (match) positions.push({ key: m.key, index: match.index });
+  }
+  positions.sort((a, b) => a.index - b.index);
+  const result = {};
+  const firstPos = positions.length > 0 ? positions[0].index : b2.length;
+  result['coreInstructions'] = b2.slice(0, firstPos);
+  for (let i = 0; i < positions.length; i++) {
+    const start = positions[i].index;
+    const end = i + 1 < positions.length ? positions[i + 1].index : b2.length;
+    result[positions[i].key] = b2.slice(start, end);
+  }
+  return result;
+}
+
+function computeBlockDiff(b2A, b2B) {
+  const blocksA = splitB2IntoBlocks(b2A);
+  const blocksB = splitB2IntoBlocks(b2B);
+  const ALL_BLOCKS = ['coreInstructions', 'customSkills', 'customAgents', 'mcpServersList', 'pluginSkills', 'settingsJson', 'envAndGit', 'autoMemory'];
+  return ALL_BLOCKS.map(block => {
+    const textA = blocksA[block] || '';
+    const textB = blocksB[block] || '';
+    const aTokens = safeCountTokens(textA);
+    const bTokens = safeCountTokens(textB);
+    const delta = bTokens - aTokens;
+    const owner = BLOCK_OWNERS_SERVER[block] || 'anthropic';
+    const status = textA === textB ? 'same' : 'changed';
+    const blockDiff = status === 'changed' ? computeUnifiedDiff(textA, textB, block, block) : '';
+    return { block, tokA: aTokens, tokB: bTokens, aTokens, bTokens, delta, status, owner, textB, blockDiff };
+  });
+}
+
+function computeUnifiedDiff(textA, textB, labelA, labelB) {
+  const linesA = textA.split('\n');
+  const linesB = textB.split('\n');
+  const result = [`--- ${labelA}`, `+++ ${labelB}`];
+  const changes = [];
+  let i = 0, j = 0;
+  while (i < linesA.length || j < linesB.length) {
+    if (i < linesA.length && j < linesB.length && linesA[i] === linesB[j]) {
+      changes.push({ type: ' ', line: linesA[i] }); i++; j++;
+    } else if (j < linesB.length && (i >= linesA.length || linesA[i] !== linesB[j])) {
+      let matchAhead = -1;
+      for (let k = 1; k <= 5 && i + k < linesA.length; k++) {
+        if (linesA[i + k] === linesB[j]) { matchAhead = k; break; }
+      }
+      if (matchAhead === -1) {
+        changes.push({ type: '+', line: linesB[j] }); j++;
+      } else {
+        for (let k = 0; k < matchAhead; k++) { changes.push({ type: '-', line: linesA[i] }); i++; }
+      }
+    } else {
+      changes.push({ type: '-', line: linesA[i] }); i++;
+    }
+  }
+  const CONTEXT = 3;
+  const hunkStarts = [];
+  for (let ci = 0; ci < changes.length; ci++) {
+    if (changes[ci].type !== ' ') hunkStarts.push(ci);
+  }
+  const hunkRanges = [];
+  let ri = 0;
+  while (ri < hunkStarts.length) {
+    const start = Math.max(0, hunkStarts[ri] - CONTEXT);
+    let end = Math.min(changes.length - 1, hunkStarts[ri] + CONTEXT);
+    while (ri + 1 < hunkStarts.length && hunkStarts[ri + 1] <= end + CONTEXT) {
+      ri++;
+      end = Math.min(changes.length - 1, hunkStarts[ri] + CONTEXT);
+    }
+    hunkRanges.push([start, end]);
+    ri++;
+  }
+  let aLine = 1, bLine = 1, ci2 = 0;
+  for (const [hStart, hEnd] of hunkRanges) {
+    while (ci2 < hStart) {
+      if (changes[ci2].type !== '+') aLine++;
+      if (changes[ci2].type !== '-') bLine++;
+      ci2++;
+    }
+    const hunkA = aLine, hunkB = bLine;
+    let aCount = 0, bCount = 0;
+    const hunkLines = [];
+    for (let ci3 = hStart; ci3 <= hEnd; ci3++) {
+      const c = changes[ci3];
+      hunkLines.push(c.type + c.line);
+      if (c.type !== '+') aCount++;
+      if (c.type !== '-') bCount++;
+    }
+    result.push(`@@ -${hunkA},${aCount} +${hunkB},${bCount} @@`);
+    for (const l of hunkLines) result.push(l);
+    for (let ci3 = hStart; ci3 <= hEnd; ci3++) {
+      if (changes[ci3].type !== '+') aLine++;
+      if (changes[ci3].type !== '-') bLine++;
+    }
+    ci2 = hEnd + 1;
+  }
+  return result.join('\n');
+}
+
+module.exports = {
+  BLOCK_OWNERS_SERVER,
+  extractAgentType,
+  splitB2IntoBlocks,
+  computeBlockDiff,
+  computeUnifiedDiff,
+};