@synkro-sh/cli 1.6.5 → 1.6.6

package/dist/bootstrap.js

@@ -733,7 +733,7 @@ var init_hookScriptsTs = __esm({
     "use strict";
     SYNKRO_COMMON_TS = `
 // Shared Synkro hook utilities \u2014 imported by all hook scripts.
-import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, renameSync, openSync, closeSync, unlinkSync } from 'node:fs';
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, renameSync, openSync, closeSync, unlinkSync, readdirSync, statSync } from 'node:fs';
 import { join, dirname, basename, extname, resolve as resolvePath } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -1002,6 +1002,10 @@ export async function loadConfig(jwt: string, query?: string): Promise<HookConfi
     scanExemptions: [],
   };
 
+  // Kick the telemetry spool drainer. Fire-and-forget: it runs concurrently
+  // with the grade that follows this call, so it adds no latency to the hook.
+  drainSpool().catch(() => {});
+
   // Local-first: fetch from the local MCP server (PGLite-backed) \u2014 zero network egress.
   const mcpPort = process.env.SYNKRO_MCP_PORT || '18931';
   try {
@@ -1596,18 +1600,104 @@ export function dispatchCapture(
   }).catch(() => {});
 }
 
+// \u2500\u2500\u2500 Durable Telemetry Spool \u2500\u2500\u2500
+// Telemetry must survive process death, container restarts, and ingest-server
+// backpressure. Instead of a fire-and-forget POST (which silently dropped
+// captures under parallel load), every event is appended synchronously to a
+// local JSONL spool \u2014 a write that completes before the function returns and
+// outlives the hook process. A background drainer (kicked from loadConfig, so
+// it overlaps the multi-second grade) batch-ships the spool to the ingest
+// server and only deletes events after a confirmed write. Ingest is idempotent
+// (ON CONFLICT DO NOTHING on event_id), so a retried or double-drained event
+// is harmless.
+
+const TELEMETRY_SPOOL = join(HOME, '.synkro', 'telemetry-spool.jsonl');
+const SPOOL_DRAIN_PREFIX = 'telemetry-spool.jsonl.draining.';
+
+// appendLocalTelemetry \u2014 durably records one telemetry event. The synchronous
+// append IS the durability guarantee; nothing here can drop the event.
 export function appendLocalTelemetry(body: Record<string, any>): void {
   const event = { ...body, _ts: new Date().toISOString() };
+  try {
+    appendFileSync(TELEMETRY_SPOOL, JSON.stringify(event) + '\\n');
+  } catch {}
+}
+
+// drainSpool \u2014 claims the spool via atomic rename, batch-ships it to the
+// ingest server, deletes on success, re-spools on failure. Fire-and-forget:
+// callers kick it and let it run concurrently with the grade.
+export async function drainSpool(): Promise<void> {
+  const dir = join(HOME, '.synkro');
+  const claimed: string[] = [];
+
+  // 1. Claim the live spool by atomic rename \u2014 a fresh spool takes new writes.
+  try {
+    if (existsSync(TELEMETRY_SPOOL) && statSync(TELEMETRY_SPOOL).size > 0) {
+      const claim = join(dir, SPOOL_DRAIN_PREFIX + process.pid + '.' + Date.now());
+      renameSync(TELEMETRY_SPOOL, claim);
+      claimed.push(claim);
+    }
+  } catch {}
+
+  // 2. Recover orphaned claim files \u2014 a previous hook died mid-drain. Only
+  // adopt claims older than 30s so we never steal another hook's in-flight drain.
+  try {
+    for (const f of readdirSync(dir)) {
+      if (!f.startsWith(SPOOL_DRAIN_PREFIX)) continue;
+      const full = join(dir, f);
+      if (claimed.indexOf(full) !== -1) continue;
+      try {
+        if (Date.now() - statSync(full).mtimeMs > 30000) claimed.push(full);
+      } catch {}
+    }
+  } catch {}
+  if (claimed.length === 0) return;
+
+  // 3. Read every event out of the claimed files.
+  const events: any[] = [];
+  for (const f of claimed) {
+    try {
+      for (const line of readFileSync(f, 'utf-8').split('\\n')) {
+        const t = line.trim();
+        if (!t) continue;
+        try { events.push(JSON.parse(t)); } catch {}
+      }
+    } catch {}
+  }
+  if (events.length === 0) {
+    for (const f of claimed) { try { unlinkSync(f); } catch {} }
+    return;
+  }
+
+  // 4. Ship to /api/ingest/batch in chunks. A token is required by the server.
   const mcpPort = process.env.SYNKRO_MCP_PORT || '18931';
   let mcpToken = '';
   try { mcpToken = readFileSync(join(HOME, '.synkro', '.mcp-jwt'), 'utf-8').trim(); } catch {}
-  if (!mcpToken) return;
-  fetch(\`http://127.0.0.1:\${mcpPort}/api/ingest\`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + mcpToken },
-    body: JSON.stringify({ data: event }),
-    signal: AbortSignal.timeout(2000),
-  }).catch(() => {});
+  if (!mcpToken) return; // leave claim files; a later drain retries them
+
+  let allOk = true;
+  for (let i = 0; i < events.length; i += 200) {
+    try {
+      const resp = await fetch('http://127.0.0.1:' + mcpPort + '/api/ingest/batch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + mcpToken },
+        body: JSON.stringify({ events: events.slice(i, i + 200) }),
+        signal: AbortSignal.timeout(8000),
+      });
+      if (!resp.ok) { allOk = false; break; }
+    } catch { allOk = false; break; }
+  }
+
+  // 5. Success \u2192 drop the claim files. Failure \u2192 re-spool for the next drain.
+  if (allOk) {
+    for (const f of claimed) { try { unlinkSync(f); } catch {} }
+  } else {
+    try {
+      appendFileSync(TELEMETRY_SPOOL, events.map(e => JSON.stringify(e)).join('\\n') + '\\n');
+      for (const f of claimed) { try { unlinkSync(f); } catch {} }
+    } catch {}
+    // if re-spool failed, claim files remain and are recovered as orphans later
+  }
 }
 
 // \u2500\u2500\u2500 Rule Mode Lookup \u2500\u2500\u2500
@@ -6327,7 +6417,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.6.5")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.6.6")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -7814,7 +7904,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.6.5");
+  console.log("1.6.6");
 }
 function printHelp() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents