Add dbc fetch service, timestamp

Author: haoruizhou

.gitignore

@@ -137,6 +137,8 @@ celerybeat.pid
 
 # Environments
 .env
+.env.local
+.env.*.local
 .envrc
 .venv
 env/

flight-recorder/.env.example

@@ -0,0 +1,4 @@
+# Fine-grained PAT with Contents:read on Western-Formula-Racing/DBC
+# Set this in your deployment environment (Cloudflare Pages, etc.)
+# DO NOT commit a real token — this file is just documentation.
+VITE_GITHUB_DBC_READONLY_TOKEN=github_pat_...

flight-recorder/src/App.tsx

@@ -10,12 +10,16 @@ class LoggingHandler {
     webSocketService.on('decoded', (decoded: any) => {
       const messages = Array.isArray(decoded) ? decoded : [decoded];
 
+      // Stamp with wall-clock time at FDR receipt.
+      // The car's msg.time is relative (ms since ECU boot) and has no
+      // meaning as a Unix timestamp — InfluxDB needs absolute epoch ms.
+      const receivedAt = Date.now();
       messages.forEach(msg => {
         if (msg?.signals) {
           loggingService.logFrame(
-            msg.time || Date.now(), 
-            msg.canId, 
-            msg.data // Using raw buffer data from processor
+            receivedAt,
+            msg.canId,
+            msg.rawBytes ?? []
           );
         }
       });

flight-recorder/src/services/LoggingHandler.ts

@@ -60,7 +60,7 @@ export class SyncService {
 
             for (const [sigName, sigData] of Object.entries(decoded.signals)) {
               const value = (sigData as any).sensorReading;
-              if (typeof value !== 'number') continue;
+              if (typeof value !== 'number' || !isFinite(value)) continue;
 
               const tags = `signalName=${this.escapeTag(sigName)},messageName=${this.escapeTag(decoded.messageName)},canId=${frame.canId}`;
               const fields = `sensorReading=${value}`;
@@ -164,6 +164,11 @@ export class SyncService {
       throw new Error(`InfluxDB write failed: ${response.status} ${response.statusText} - ${errorText}`);
     }
   }
+
+  /** Drop the cached processor so the next sync creates a fresh one from the current dbcFile. */
+  public invalidateProcessor(): void {
+    this.processor = null;
+  }
 }
 
 export const syncService = new SyncService();

flight-recorder/src/services/SyncService.ts

@@ -170,6 +170,16 @@ export class WebSocketService {
   public getMessageCount(): number {
     return this.messageCount;
   }
+
+  /**
+   * Discard the cached CAN processor so the next message creates a fresh one
+   * from the current dbcFile. Call this after fetching a new DBC.
+   */
+  public async resetProcessor(): Promise<void> {
+    this.processor = null;
+    this.processor = await createCanProcessor();
+    console.log('[WebSocket] CAN processor reloaded with new DBC');
+  }
 }
 
 export const webSocketService = new WebSocketService();

flight-recorder/src/services/WebSocketService.ts

@@ -77,6 +77,7 @@ interface DecodedMessage {
     };
   };
   rawData: string;
+  rawBytes: number[]; // Original byte array — preserved for IndexedDB storage
 }
 
 // Type for batch processing results
@@ -398,6 +399,7 @@ export function decodeCanMessage(
         time: time,
         signals: {},
         rawData: rawDataStr,
+        rawBytes: messageData,
       };
     }
 
@@ -420,6 +422,7 @@ export function decodeCanMessage(
       time: time,
       signals,
       rawData: rawDataStr,
+      rawBytes: messageData,
     };
   } catch (error) {
     console.error(`Error decoding message ${canId}:`, error);
@@ -626,6 +629,115 @@ export async function createCanProcessor(): Promise<any> {
   };
 }
 
+const GITHUB_REPO = 'Western-Formula-Racing/DBC';
+// Fine-grained PAT injected at build time via VITE_GITHUB_TOKEN env var.
+// Needs Contents:read on Western-Formula-Racing/DBC.
+const GITHUB_TOKEN = (import.meta as any).env?.VITE_GITHUB_DBC_READONLY_TOKEN ?? '';
+
+function githubHeaders(raw = false): HeadersInit {
+  const h: HeadersInit = {
+    Accept: raw ? 'application/vnd.github.v3.raw' : 'application/vnd.github.v3+json',
+    'X-GitHub-Api-Version': '2022-11-28',
+  };
+  if (GITHUB_TOKEN) (h as Record<string, string>)['Authorization'] = `Bearer ${GITHUB_TOKEN}`;
+  return h;
+}
+
+export interface DBCFileInfo {
+  name: string;
+  path: string;
+  sha: string;
+  size: number;
+}
+
+export interface DBCApplyResult {
+  ok: boolean;
+  message: string;
+  commitSha?: string;
+  commitMessage?: string;
+}
+
+/** List all .dbc files in the Western-Formula-Racing/DBC repo root. */
+export async function listDBCFiles(): Promise<{ ok: boolean; files?: DBCFileInfo[]; message?: string }> {
+  try {
+    const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/contents/`, {
+      headers: githubHeaders(),
+    });
+    if (!res.ok) {
+      return { ok: false, message: `GitHub ${res.status}: ${res.statusText}` };
+    }
+    const items: any[] = await res.json();
+    const files: DBCFileInfo[] = items
+      .filter(f => f.type === 'file' && f.name.toLowerCase().endsWith('.dbc'))
+      .map(f => ({ name: f.name, path: f.path, sha: f.sha, size: f.size }));
+    return { ok: true, files };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+/**
+ * Fetch a specific DBC file from the repo, cache it locally, and update the
+ * in-memory dbcFile so the next createCanProcessor() call uses it.
+ * Also fetches the latest commit that touched the file for display.
+ */
+export async function fetchAndApplyDBC(filename: string): Promise<DBCApplyResult> {
+  // Fetch raw file content
+  let fileRes: Response;
+  try {
+    fileRes = await fetch(
+      `https://api.github.com/repos/${GITHUB_REPO}/contents/${encodeURIComponent(filename)}`,
+      { headers: githubHeaders(true) }
+    );
+  } catch (err) {
+    return { ok: false, message: `Network error: ${err instanceof Error ? err.message : String(err)}` };
+  }
+
+  if (!fileRes.ok) {
+    return { ok: false, message: `GitHub ${fileRes.status}: ${fileRes.statusText}` };
+  }
+
+  const dbcText = await fileRes.text();
+  if (!dbcText.trim()) {
+    return { ok: false, message: 'Fetched DBC is empty' };
+  }
+
+  // Fetch the most recent commit that touched this file
+  let commitSha = '';
+  let commitMessage = '';
+  try {
+    const commitRes = await fetch(
+      `https://api.github.com/repos/${GITHUB_REPO}/commits?path=${encodeURIComponent(filename)}&per_page=1`,
+      { headers: githubHeaders() }
+    );
+    if (commitRes.ok) {
+      const commits: any[] = await commitRes.json();
+      if (commits.length > 0) {
+        commitSha = commits[0].sha.slice(0, 7);
+        commitMessage = commits[0].commit.message.split('\n')[0];
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Update in-memory state immediately
+  dbcFile = dbcText;
+  usingCache = true;
+  localStorage.setItem('dbc-selected-file', filename);
+
+  // Persist to Cache API, fall back to localStorage
+  try {
+    const cache = await caches.open('dbc-files');
+    await cache.put('cache.dbc', new Response(dbcText, {
+      headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+    }));
+  } catch {
+    try { localStorage.setItem('dbc-file-content', dbcText); } catch { /* ignore */ }
+  }
+
+  const sizeKb = (dbcText.length / 1024).toFixed(1);
+  return { ok: true, message: `${filename} — ${sizeKb} KB`, commitSha, commitMessage };
+}
+
 /**
  * Example: Setup WebSocket listener with CAN processor
  * Usage in your browser app: