npm - codexmeter - Versions diffs - 1.0.0 → 1.0.2 - Mend

codexmeter 1.0.0 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/bin/codexmeter.js +1 -0
package/dist/assets/index-C0qLYGUY.css +1 -0
package/dist/assets/index-M87czq50.js +113 -0
package/dist/index.html +2 -2
package/package.json +5 -2
package/server/aggregator.js +79 -7
package/server/cost-catalog.js +1 -1
package/server/export-replay.js +80 -0
package/server/export-video.js +313 -0
package/server/index.js +68 -1
package/server/ingest.js +147 -42
package/server/live-state.js +61 -2
package/server/rollout-reader.js +87 -5
package/src/utils/animationsDefault.js +244 -0
package/dist/assets/index-DJWqyRDh.css +0 -1
package/dist/assets/index-DZKogILW.js +0 -113

package/dist/index.html CHANGED Viewed

@@ -7,8 +7,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-DZKogILW.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DJWqyRDh.css">
+    <script type="module" crossorigin src="/assets/index-M87czq50.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C0qLYGUY.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "codexmeter",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Local telemetry dashboard for Codex CLI usage",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bin",
     "server",
+    "src/utils/animationsDefault.js",
     "dist",
     "README.md",
     "package.json"
@@ -25,7 +26,9 @@
     "commander": "^13.1.0",
     "express": "^5.1.0",
     "fast-glob": "^3.3.3",
-    "open": "^10.1.0"
+    "ffmpeg-static": "^5.2.0",
+    "open": "^10.1.0",
+    "playwright-core": "^1.58.2"
   },
   "devDependencies": {
     "@tanstack/react-table": "^8.21.3",

package/server/aggregator.js CHANGED Viewed

@@ -240,7 +240,10 @@ function buildDaily(rawSessions, groupedSessions, tz) {
     const startDay = toDayKeyInTz(startMs);
     const endDay = toDayKeyInTz(endMs - 1);
-    if (startDay === endDay) {
+    if (s.has_usage_by_day) {
+      addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKeyInTz, s);
+      addUsageByDay(dayMap, s);
+    } else if (startDay === endDay) {
       addToDay(dayMap, startDay, s, 1.0);
     } else {
       let cursor = dayStartMs(startDay);
@@ -314,12 +317,25 @@ function buildHeatmap(rawSessions, groupedSessions, tz) {
   const dayMap = new Map();
   for (const s of rawSessions) {
     if (!s.started_at) continue;
-    const dk = toDayKeyInTz(s.started_at * 1000);
-    if (!dayMap.has(dk)) dayMap.set(dk, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
-    const d = dayMap.get(dk);
-    d.tokens += s.tokens_used;
-    if (s.cost !== null) d.cost += s.cost;
-    d.sessions++;
+    if (s.has_usage_by_day) {
+      for (const usageDay of s.usage_by_day || []) {
+        const dayKey = usageDay.day;
+        if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+        const d = dayMap.get(dayKey);
+        d.tokens += usageDay.tokens || 0;
+        if (usageDay.cost !== null) d.cost += usageDay.cost;
+      }
+      const startDay = toDayKeyInTz(s.started_at * 1000);
+      if (!dayMap.has(startDay)) dayMap.set(startDay, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+      dayMap.get(startDay).sessions++;
+    } else {
+      const dk = toDayKeyInTz(s.started_at * 1000);
+      if (!dayMap.has(dk)) dayMap.set(dk, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+      const d = dayMap.get(dk);
+      d.tokens += s.tokens_used;
+      if (s.cost !== null) d.cost += s.cost;
+      d.sessions++;
+    }
   }
   for (const s of groupedSessions) {
@@ -332,6 +348,62 @@ function buildHeatmap(rawSessions, groupedSessions, tz) {
   return Object.fromEntries(dayMap);
 }
+function addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKeyInTz, session) {
+  if (startDay === endDay) {
+    addPresenceToDay(dayMap, startDay, session, 1.0);
+    return;
+  }
+  let cursor = dayStartMs(startDay);
+  while (cursor < endMs) {
+    const nextDay = cursor + 86400000;
+    const overlapStart = Math.max(cursor, startMs);
+    const overlapEnd = Math.min(nextDay, endMs);
+    const fraction = (overlapEnd - overlapStart) / totalDur;
+    if (fraction > 0) addPresenceToDay(dayMap, toDayKeyInTz(cursor), session, fraction);
+    cursor = nextDay;
+  }
+}
+function addPresenceToDay(dayMap, dayKey, session, fraction) {
+  if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
+  const d = dayMap.get(dayKey);
+  if (fraction > 0.001) d.sessions++;
+  const fKey = session.agent_family;
+  if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, sessions: 0 };
+  if (fraction > 0.001) d.by_family[fKey].sessions++;
+  const rKey = session.repo_label || 'unknown';
+  if (!d.by_repo[rKey]) d.by_repo[rKey] = { tokens: 0, cost: 0, sessions: 0 };
+  if (fraction > 0.001) d.by_repo[rKey].sessions++;
+}
+function addUsageByDay(dayMap, session) {
+  for (const usageDay of session.usage_by_day || []) {
+    const dayKey = usageDay.day;
+    if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
+    const d = dayMap.get(dayKey);
+    d.tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.cost += usageDay.cost;
+    const mKey = session.model_name || 'unknown';
+    if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+    d.by_model[mKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.by_model[mKey].cost += usageDay.cost;
+    const fKey = session.agent_family;
+    if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, sessions: 0 };
+    d.by_family[fKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.by_family[fKey].cost += usageDay.cost;
+    const rKey = session.repo_label || 'unknown';
+    if (!d.by_repo[rKey]) d.by_repo[rKey] = { tokens: 0, cost: 0, sessions: 0 };
+    d.by_repo[rKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.by_repo[rKey].cost += usageDay.cost;
+  }
+}
 function dayStartMs(dayKey) {
   const [y, m, d] = dayKey.split('-').map(Number);
   return new Date(y, m - 1, d).getTime();

package/server/cost-catalog.js CHANGED Viewed

@@ -32,7 +32,7 @@ export function getCacheAwareRate(modelName) {
   return INPUT_FRACTION * effectiveInputRate + OUTPUT_FRACTION * entry.output;
 }
-function calculateCostFromUsage(modelName, usage) {
+export function calculateCostFromUsage(modelName, usage) {
   if (!modelName || !usage) return null;
   const entry = getPricing()[modelName];
   if (!entry) return null;

package/server/export-replay.js ADDED Viewed

@@ -0,0 +1,80 @@
+function clonePayload(payload) {
+  return JSON.parse(JSON.stringify(payload));
+}
+export function createReplayCaptureState() {
+  return {
+    ingest_id: null,
+    active: false,
+    available: false,
+    started_at_ms: 0,
+    completed_at_ms: 0,
+    events: [],
+  };
+}
+export function resetReplayCapture(replay) {
+  replay.ingest_id = null;
+  replay.active = false;
+  replay.available = false;
+  replay.started_at_ms = 0;
+  replay.completed_at_ms = 0;
+  replay.events = [];
+}
+export function beginReplayCapture(replay, ingestId, bootstrapPayload) {
+  resetReplayCapture(replay);
+  replay.ingest_id = ingestId;
+  replay.active = true;
+  replay.started_at_ms = Date.now();
+  replay.events.push({
+    event: 'bootstrap',
+    at_ms: 0,
+    payload: clonePayload(bootstrapPayload),
+  });
+}
+export function recordReplayEvent(replay, event, payload) {
+  if (!replay?.active) return;
+  if (!['progress', 'patch', 'complete'].includes(event)) return;
+  replay.events.push({
+    event,
+    at_ms: Math.max(0, Date.now() - replay.started_at_ms),
+    payload: clonePayload(payload),
+  });
+  if (event === 'complete') {
+    replay.active = false;
+    replay.available = true;
+    replay.completed_at_ms = Date.now();
+  }
+}
+export function failReplayCapture(replay) {
+  if (!replay) return;
+  replay.active = false;
+  replay.available = false;
+}
+export function getReplaySnapshot(replay) {
+  if (!replay?.available || !replay.events.length) return null;
+  const [bootstrap, ...rest] = replay.events;
+  const durationMs = replay.events[replay.events.length - 1]?.at_ms || 0;
+  return {
+    ready: true,
+    ingest_id: replay.ingest_id,
+    started_at_ms: replay.started_at_ms,
+    completed_at_ms: replay.completed_at_ms,
+    duration_ms: durationMs,
+    bootstrap: bootstrap ? {
+      event: bootstrap.event,
+      at_ms: bootstrap.at_ms,
+      payload: clonePayload(bootstrap.payload),
+    } : null,
+    events: rest.map((event) => ({
+      event: event.event,
+      at_ms: event.at_ms,
+      mode: event.event === 'patch' ? 'patch' : 'progress',
+      payload: clonePayload(event.payload),
+    })),
+  };
+}

package/server/export-video.js ADDED Viewed

@@ -0,0 +1,313 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import os from 'os';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+import ffmpegPath from 'ffmpeg-static';
+import { chromium } from 'playwright-core';
+import { OVERVIEW_INGEST_ANIMATION } from '../src/utils/animationsDefault.js';
+const EXPORT_WIDTH = OVERVIEW_INGEST_ANIMATION.videoExport?.width ?? 1080;
+const EXPORT_HEIGHT = OVERVIEW_INGEST_ANIMATION.videoExport?.height ?? 864;
+const EXPORT_FPS = OVERVIEW_INGEST_ANIMATION.videoExport?.fps ?? 60;
+const EXPORT_INTRO_DURATION_MS = OVERVIEW_INGEST_ANIMATION.videoExport?.introDurationMs ?? 900;
+const EXPORT_REPLAY_DURATION_MS = OVERVIEW_INGEST_ANIMATION.videoExport?.replayDurationMs ?? 8000;
+const EXPORT_TAIL_DURATION_MS = OVERVIEW_INGEST_ANIMATION.videoExport?.tailDurationMs ?? 5000;
+const EXPORT_TOTAL_DURATION_MS = EXPORT_INTRO_DURATION_MS + EXPORT_REPLAY_DURATION_MS + EXPORT_TAIL_DURATION_MS;
+const EXPORT_TAIL_REPLAY_FRACTION = OVERVIEW_INGEST_ANIMATION.videoExport?.tailReplayFraction ?? 0.72;
+const EXPORT_CAPTURE_FORMAT = OVERVIEW_INGEST_ANIMATION.videoExport?.captureFormat ?? 'png';
+const EXPORT_JPEG_QUALITY = OVERVIEW_INGEST_ANIMATION.videoExport?.jpegQuality ?? 92;
+const EXPORT_CRF = OVERVIEW_INGEST_ANIMATION.videoExport?.crf ?? 20;
+const EXPORT_ENCODER_PRESET = OVERVIEW_INGEST_ANIMATION.videoExport?.encoderPreset ?? 'fast';
+export function createExportManager({ getReplay, getSettledEnvelope, getBaseUrl }) {
+  const jobs = new Map();
+  return {
+    async startOverviewVideoJob(clientBaseUrl) {
+      const replay = getReplay();
+      const settledEnvelope = getSettledEnvelope ? getSettledEnvelope() : null;
+      if (!replay?.bootstrap) {
+        const err = new Error('No completed ingest replay is available yet.');
+        err.statusCode = 409;
+        throw err;
+      }
+      const jobId = randomUUID();
+      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'codexmeter-video-'));
+      const framesDir = path.join(tempDir, 'frames');
+      const outputPath = path.join(tempDir, 'codexmeter-overview.mp4');
+      await fs.mkdir(framesDir, { recursive: true });
+      const job = {
+        id: jobId,
+        type: 'overview-video',
+        status: 'queued',
+        phase: 'preparing',
+        progress: 0,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        replay_ingest_id: replay.ingest_id,
+        replay,
+        settled_envelope: settledEnvelope,
+        width: EXPORT_WIDTH,
+        height: EXPORT_HEIGHT,
+        fps: EXPORT_FPS,
+        intro_duration_ms: EXPORT_INTRO_DURATION_MS,
+        replay_duration_ms: EXPORT_REPLAY_DURATION_MS,
+        tail_duration_ms: EXPORT_TAIL_DURATION_MS,
+        tail_replay_fraction: EXPORT_TAIL_REPLAY_FRACTION,
+        duration_ms: EXPORT_TOTAL_DURATION_MS,
+        capture_format: EXPORT_CAPTURE_FORMAT,
+        jpeg_quality: EXPORT_JPEG_QUALITY,
+        crf: EXPORT_CRF,
+        encoder_preset: EXPORT_ENCODER_PRESET,
+        temp_dir: tempDir,
+        frames_dir: framesDir,
+        output_path: outputPath,
+        file_name: `codexmeter-overview-${jobId.slice(0, 8)}.mp4`,
+        client_base_url: clientBaseUrl || null,
+        error: null,
+      };
+      jobs.set(jobId, job);
+      void runOverviewVideoJob(job, replay, getBaseUrl);
+      return sanitizeJob(job);
+    },
+    getJob(jobId) {
+      return jobs.get(jobId) || null;
+    },
+    listJobs() {
+      return [...jobs.values()];
+    },
+    getRenderPayload(jobId) {
+      const job = jobs.get(jobId);
+      if (!job) return null;
+      return {
+        jobId: job.id,
+        width: job.width,
+        height: job.height,
+        fps: job.fps,
+        durationMs: job.duration_ms,
+        introDurationMs: job.intro_duration_ms,
+        replayDurationMs: job.replay_duration_ms,
+        tailDurationMs: job.tail_duration_ms,
+        tailReplayFraction: job.tail_replay_fraction,
+        replay: job.replay,
+        settledEnvelope: job.settled_envelope,
+      };
+    },
+    sanitizeJob,
+  };
+  function sanitizeJob(job) {
+    if (!job) return null;
+    return {
+      id: job.id,
+      type: job.type,
+      status: job.status,
+      phase: job.phase,
+      progress: job.progress,
+      created_at: job.created_at,
+      updated_at: job.updated_at,
+      replay_ingest_id: job.replay_ingest_id,
+      file_name: job.file_name,
+      download_url: job.status === 'complete' ? `/api/export/${job.id}/file` : null,
+      error: job.error,
+    };
+  }
+  async function runOverviewVideoJob(job, replay, getBaseUrlFn) {
+    try {
+      updateJob(job, 'rendering', 0.02, 'running');
+      const baseUrl = await getBaseUrlFn(job.client_base_url);
+      const browserPath = await detectBrowserExecutable();
+      const browser = await chromium.launch({
+        headless: true,
+        executablePath: browserPath,
+      });
+      try {
+        const page = await browser.newPage({
+          viewport: { width: job.width, height: job.height },
+          deviceScaleFactor: 1,
+        });
+        const exportUrl = `${baseUrl}/?export=overview-video&job=${encodeURIComponent(job.id)}`;
+        await page.goto(exportUrl, { waitUntil: 'networkidle' });
+        await page.waitForFunction(
+          (expectedJobId) => window.__CODEXMETER_EXPORT__?.ready === true && window.__CODEXMETER_EXPORT__?.jobId === expectedJobId,
+          job.id,
+          { timeout: 30000 }
+        );
+        const totalFrames = Math.max(2, Math.ceil((job.duration_ms / 1000) * job.fps));
+        const frameStepMs = 1000 / job.fps;
+        for (let i = 0; i < totalFrames; i += 1) {
+          const timeMs = Math.min(job.duration_ms, Math.round(i * frameStepMs));
+          await page.evaluate((ms) => window.__CODEXMETER_EXPORT__?.seek(ms), timeMs);
+          await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => resolve())));
+          const frameExt = job.capture_format === 'jpeg' ? 'jpg' : 'png';
+          const framePath = path.join(job.frames_dir, `${String(i).padStart(5, '0')}.${frameExt}`);
+          if (job.capture_format === 'jpeg') {
+            await page.screenshot({ path: framePath, type: 'jpeg', quality: job.jpeg_quality });
+          } else {
+            await page.screenshot({ path: framePath, type: 'png' });
+          }
+          updateJob(job, 'rendering', 0.05 + ((i + 1) / totalFrames) * 0.8, 'running');
+        }
+      } finally {
+        await browser.close();
+      }
+      updateJob(job, 'encoding', 0.9, 'running');
+      await encodeFramesToMp4(job.frames_dir, job.output_path, job.fps, {
+        captureFormat: job.capture_format,
+        crf: job.crf,
+        encoderPreset: job.encoder_preset,
+      });
+      updateJob(job, 'complete', 1, 'complete');
+    } catch (err) {
+      job.error = err instanceof Error ? err.message : String(err);
+      updateJob(job, 'failed', job.progress || 0, 'failed');
+    }
+  }
+}
+export function createVideoExportManager() {
+  let replayGetter = () => null;
+  let settledEnvelopeGetter = () => null;
+  let baseUrlResolver = async (clientBaseUrl) => clientBaseUrl || null;
+  const manager = createExportManager({
+    getReplay: () => replayGetter(),
+    getSettledEnvelope: () => settledEnvelopeGetter(),
+    getBaseUrl: (clientBaseUrl) => baseUrlResolver(clientBaseUrl),
+  });
+  manager.setReplayGetter = (fn) => {
+    replayGetter = fn;
+  };
+  manager.setSettledEnvelopeGetter = (fn) => {
+    settledEnvelopeGetter = fn;
+  };
+  manager.setBaseUrlResolver = (fn) => {
+    baseUrlResolver = fn;
+  };
+  return manager;
+}
+export function startOverviewVideoExport(manager, { replay, settledEnvelope, appBaseUrl }) {
+  manager.setReplayGetter(() => replay);
+  manager.setSettledEnvelopeGetter(() => settledEnvelope);
+  manager.setBaseUrlResolver(async (clientBaseUrl) => clientBaseUrl || appBaseUrl);
+  return manager.startOverviewVideoJob(appBaseUrl);
+}
+export function getVideoExportJob(manager, jobId) {
+  return manager.getJob(jobId);
+}
+export function getActiveVideoExportJob(manager) {
+  const jobs = manager.listJobs ? manager.listJobs() : [];
+  return jobs
+    .filter((job) => job.status === 'queued' || job.status === 'running')
+    .sort((a, b) => Date.parse(b.created_at) - Date.parse(a.created_at))[0] || null;
+}
+export function createJobSummary(job) {
+  if (!job) return null;
+  return {
+    id: job.id,
+    type: job.type,
+    status: job.status,
+    phase: job.phase,
+    progress: job.progress,
+    created_at: job.created_at,
+    updated_at: job.updated_at,
+    replay_ingest_id: job.replay_ingest_id,
+    file_name: job.file_name,
+    download_url: job.status === 'complete' ? `/api/export/${job.id}/file` : null,
+    error: job.error || null,
+  };
+}
+function updateJob(job, phase, progress, status) {
+  job.phase = phase;
+  job.progress = Math.max(0, Math.min(progress, 1));
+  job.status = status;
+  job.updated_at = new Date().toISOString();
+}
+async function detectBrowserExecutable() {
+  if (process.env.CODEXMETER_EXPORT_BROWSER && fsSync.existsSync(process.env.CODEXMETER_EXPORT_BROWSER)) {
+    return process.env.CODEXMETER_EXPORT_BROWSER;
+  }
+  const candidates = process.platform === 'win32'
+    ? [
+      process.env['PROGRAMFILES'] ? path.join(process.env['PROGRAMFILES'], 'Google', 'Chrome', 'Application', 'chrome.exe') : null,
+      process.env['PROGRAMFILES(X86)'] ? path.join(process.env['PROGRAMFILES(X86)'], 'Google', 'Chrome', 'Application', 'chrome.exe') : null,
+      process.env['PROGRAMFILES'] ? path.join(process.env['PROGRAMFILES'], 'Microsoft', 'Edge', 'Application', 'msedge.exe') : null,
+      process.env['PROGRAMFILES(X86)'] ? path.join(process.env['PROGRAMFILES(X86)'], 'Microsoft', 'Edge', 'Application', 'msedge.exe') : null,
+    ]
+    : process.platform === 'darwin'
+      ? [
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+      ]
+      : [
+        '/usr/bin/google-chrome',
+        '/usr/bin/chromium',
+        '/usr/bin/chromium-browser',
+        '/usr/bin/microsoft-edge',
+      ];
+  for (const candidate of candidates.filter(Boolean)) {
+    if (fsSync.existsSync(candidate)) return candidate;
+  }
+  const err = new Error('No supported Chrome/Chromium/Edge executable was found for video export.');
+  err.statusCode = 500;
+  throw err;
+}
+async function encodeFramesToMp4(framesDir, outputPath, fps, { captureFormat, crf, encoderPreset }) {
+  const extension = captureFormat === 'jpeg' ? 'jpg' : 'png';
+  const inputPattern = path.join(framesDir, `%05d.${extension}`);
+  if (!ffmpegPath) {
+    throw new Error('ffmpeg-static is unavailable');
+  }
+  await new Promise((resolve, reject) => {
+    const proc = spawn(ffmpegPath, [
+      '-y',
+      '-framerate', String(fps),
+      '-i', inputPattern,
+      '-c:v', 'libx264',
+      '-tune', 'animation',
+      '-preset', String(encoderPreset || 'fast'),
+      '-crf', String(crf ?? 20),
+      '-profile:v', 'high',
+      '-pix_fmt', 'yuv420p',
+      '-movflags', '+faststart',
+      outputPath,
+    ], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let stderr = '';
+    proc.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on('error', reject);
+    proc.on('exit', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `ffmpeg exited with code ${code}`));
+    });
+  });
+}

package/server/index.js CHANGED Viewed

@@ -1,13 +1,15 @@
 import express from 'express';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { attachLiveSubscriber, createIngestState, detachLiveSubscriber, restartIngest, runIngest } from './ingest.js';
+import { attachLiveSubscriber, createIngestState, detachLiveSubscriber, getLatestReplay, restartIngest, runIngest } from './ingest.js';
+import { createJobSummary, createVideoExportManager, getActiveVideoExportJob, getVideoExportJob, startOverviewVideoExport } from './export-video.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function createServer(codexHome, opts = {}) {
   const app = express();
   const state = createIngestState();
+  const exportManager = createVideoExportManager();
   const distDir = path.join(__dirname, '..', 'dist');
   const apiOnly = opts.devApiOnly === true;
   const ingestOpts = { ...opts };
@@ -77,6 +79,71 @@ export function createServer(codexHome, opts = {}) {
   app.get('/api/heatmap', wrap('heatmap'));
   app.get('/api/families', wrap('families'));
+  app.post('/api/export/overview-video', async (req, res) => {
+    const replay = getLatestReplay(state);
+    if (!replay) {
+      res.status(409).json({ error: 'No completed ingest replay is available yet.' });
+      return;
+    }
+    const appBaseUrl = req.get('x-codexmeter-client-base') || opts.frontendBaseUrl || `${req.protocol}://${req.get('host')}`;
+    const settledEnvelope = state.aggregates ? {
+      overview: { data: state.aggregates.overview },
+      repos: { data: state.aggregates.repos },
+      models: { data: state.aggregates.models },
+      families: { data: state.aggregates.families },
+      daily: { data: state.aggregates.daily },
+      heatmap: { data: state.aggregates.heatmap },
+    } : null;
+    try {
+      const job = await startOverviewVideoExport(exportManager, { replay, settledEnvelope, appBaseUrl });
+      res.status(202).json(createJobSummary(job, `${req.protocol}://${req.get('host')}`));
+    } catch (err) {
+      res.status(err.statusCode || 500).json({ error: err.message || String(err) });
+    }
+  });
+  app.get('/api/export/active', (req, res) => {
+    const job = getActiveVideoExportJob(exportManager);
+    if (!job) {
+      res.json({ job: null });
+      return;
+    }
+    res.json({ job: createJobSummary(job, `${req.protocol}://${req.get('host')}`) });
+  });
+  app.get('/api/export/:jobId/status', (req, res) => {
+    const job = getVideoExportJob(exportManager, req.params.jobId);
+    if (!job) {
+      res.status(404).json({ error: 'Export job not found.' });
+      return;
+    }
+    res.json(createJobSummary(job, `${req.protocol}://${req.get('host')}`));
+  });
+  app.get('/api/export/:jobId/render-data', (req, res) => {
+    const job = getVideoExportJob(exportManager, req.params.jobId);
+    if (!job) {
+      res.status(404).json({ error: 'Export job not found.' });
+      return;
+    }
+    const payload = exportManager.getRenderPayload(req.params.jobId);
+    if (!payload) {
+      res.status(404).json({ error: 'Export render data not found.' });
+      return;
+    }
+    res.json(payload);
+  });
+  app.get('/api/export/:jobId/file', (req, res) => {
+    const job = getVideoExportJob(exportManager, req.params.jobId);
+    if (!job || job.status !== 'complete' || !job.output_path) {
+      res.status(404).json({ error: 'Export file not ready.' });
+      return;
+    }
+    res.download(job.output_path, job.file_name || `codexmeter-overview-${job.id}.mp4`);
+  });
   app.get('/api/sessions', (req, res) => {
     const q = (req.query.q || '').toLowerCase();
     let sessions = state.sessions || [];