@synkro-sh/cli 1.6.5 → 1.6.7

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
@@ -5768,6 +5858,7 @@ __export(dockerInstall_exports, {
   dockerStop: () => dockerStop,
   dockerUpdate: () => dockerUpdate,
   imageTag: () => imageTag,
+  readContainerConfig: () => readContainerConfig,
   resolveWorkerConfig: () => resolveWorkerConfig,
   splitWorkers: () => splitWorkers,
   waitForContainerReady: () => waitForContainerReady
@@ -6001,6 +6092,34 @@ function dockerStatus() {
     healthz: `http://127.0.0.1:${HOST_MCP_PORT}/`
   };
 }
+function readContainerConfig() {
+  const r = spawnSync2("docker", ["inspect", "--format", "{{json .Config.Env}}", CONTAINER_NAME], {
+    encoding: "utf-8",
+    timeout: 5e3
+  });
+  if (r.status !== 0 || !r.stdout) return null;
+  let env;
+  try {
+    env = JSON.parse(r.stdout.trim());
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(env)) return null;
+  const get = (k) => {
+    const hit = env.find((e) => typeof e === "string" && e.startsWith(k + "="));
+    return hit ? hit.slice(k.length + 1) : void 0;
+  };
+  const num = (s) => {
+    if (s === void 0) return void 0;
+    const n = parseInt(s, 10);
+    return Number.isFinite(n) ? n : void 0;
+  };
+  return {
+    claudeWorkers: num(get("CLAUDE_WORKERS")),
+    cursorWorkers: num(get("CURSOR_WORKERS")),
+    connectedRepo: get("SYNKRO_CONNECTED_REPO") || void 0
+  };
+}
 async function dockerSafeStop() {
   const status = dockerStatus();
   if (!status.running) {
@@ -6327,7 +6446,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.7")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -7450,22 +7569,22 @@ import { existsSync as existsSync11, rmSync, readdirSync as readdirSync3 } from
 import { homedir as homedir10 } from "os";
 import { join as join10 } from "path";
 import { spawnSync as spawnSync4 } from "child_process";
-async function tearDownLocalCC(purge) {
+import { createInterface as createInterface4 } from "readline";
+async function tearDownLocalCC() {
   const docker = dockerStatus();
   if (docker.running) {
     await dockerSafeStop();
-    console.log("\u2713 stopped synkro-server container (data snapshot saved)");
+    console.log("\u2713 stopped synkro-server container");
   } else {
     console.log("\xB7 no synkro-server container running");
   }
   dockerRemove();
-  if (purge) {
-    try {
-      const image = imageTag();
-      spawnSync4("docker", ["rmi", image], { encoding: "utf-8", timeout: 3e4 });
-      console.log(`\u2713 removed Docker image ${image}`);
-    } catch {
-    }
+  console.log("\u2713 removed synkro-server container");
+  try {
+    const image = imageTag();
+    const r = spawnSync4("docker", ["rmi", "-f", image], { encoding: "utf-8", timeout: 3e4 });
+    console.log(r.status === 0 ? `\u2713 removed Docker image ${image}` : "\xB7 no Docker image to remove");
+  } catch {
   }
   if (needsKeychainBridge()) {
     try {
@@ -7477,10 +7596,31 @@ async function tearDownLocalCC(purge) {
   uninstallLocalCC();
   console.log("\u2713 cleaned ~/.claude.json entries");
 }
+function confirmPurge() {
+  console.log("\u26A0  WARNING \u2014 synkro uninstall --purge");
+  console.log("   This permanently deletes ALL Synkro data on this machine,");
+  console.log("   including every scan finding, telemetry record, and backup in");
+  console.log("   ~/.synkro/pgdata and ~/.synkro/pgdata-backups. It cannot be undone.\n");
+  if (!process.stdin.isTTY) {
+    console.log("   Non-interactive shell \u2014 re-run in a terminal to confirm.");
+    return Promise.resolve(false);
+  }
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve3) => {
+    rl.question("   Type 'yes' to wipe everything (anything else cancels): ", (answer) => {
+      rl.close();
+      resolve3(answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
 async function disconnectCommand(args2 = []) {
   const purge = args2.includes("--purge");
-  console.log("Synkro disconnect starting...\n");
-  await tearDownLocalCC(purge);
+  if (purge && !await confirmPurge()) {
+    console.log("\nAborted \u2014 nothing was removed.");
+    return;
+  }
+  console.log("\nSynkro uninstall starting...\n");
+  await tearDownLocalCC();
   const agents = detectAgents();
   let sawClaudeCode = false;
   for (const agent of agents) {
@@ -7501,31 +7641,32 @@ async function disconnectCommand(args2 = []) {
     const cursorMcpRemoved = uninstallCursorMcpConfig();
     console.log(`${cursorMcpRemoved ? "\u2713" : "\xB7"} MCP guardrails (Cursor): ${cursorMcpRemoved ? "removed from ~/.cursor/mcp.json" : "no entry found"}`);
   }
-  if (purge) {
-    if (existsSync11(SYNKRO_DIR5)) {
-      const pgdataPath = join10(SYNKRO_DIR5, "pgdata");
-      const backupsPath = join10(SYNKRO_DIR5, "pgdata-backups");
+  if (existsSync11(SYNKRO_DIR5)) {
+    if (purge) {
+      rmSync(SYNKRO_DIR5, { recursive: true, force: true });
+      console.log(`\u2713 wiped ${SYNKRO_DIR5} entirely \u2014 including all scan data and backups`);
+    } else {
+      const keep = /* @__PURE__ */ new Set([join10(SYNKRO_DIR5, "pgdata"), join10(SYNKRO_DIR5, "pgdata-backups")]);
       const preserved = [];
       for (const entry of readdirSync3(SYNKRO_DIR5)) {
         const full = join10(SYNKRO_DIR5, entry);
-        if (full === pgdataPath || full === backupsPath) {
+        if (keep.has(full)) {
           preserved.push(entry);
           continue;
         }
         rmSync(full, { recursive: true, force: true });
       }
       if (preserved.length > 0) {
-        console.log(`\u2713 Removed ${SYNKRO_DIR5} config (preserved: ${preserved.join(", ")} \u2014 your data is safe)`);
+        console.log(`\u2713 removed Synkro config from ${SYNKRO_DIR5} (kept your scan data: ${preserved.join(", ")})`);
+        console.log("  run `synkro uninstall --purge` to delete that too");
       } else {
-        console.log(`\u2713 Removed ${SYNKRO_DIR5}`);
+        console.log(`\u2713 removed ${SYNKRO_DIR5}`);
       }
-    } else {
-      console.log(`\xB7 ${SYNKRO_DIR5} already gone, nothing to remove`);
     }
-  } else if (existsSync11(SYNKRO_DIR5)) {
-    console.log(`Config preserved at ${SYNKRO_DIR5}. Run with --purge to remove.`);
+  } else {
+    console.log(`\xB7 ${SYNKRO_DIR5} already gone`);
   }
-  console.log("\nSynkro disconnected.");
+  console.log(purge ? "\nSynkro fully removed \u2014 this machine is clean, as if it was never installed." : "\nSynkro uninstalled. Your scan data is preserved.");
 }
 var SYNKRO_DIR5;
 var init_disconnect = __esm({
@@ -7722,7 +7863,8 @@ var lifecycle_exports = {};
 __export(lifecycle_exports, {
   restartCommand: () => restartCommand,
   startCommand: () => startCommand,
-  stopCommand: () => stopCommand
+  stopCommand: () => stopCommand,
+  updateCommand: () => updateCommand
 });
 async function stopCommand() {
   assertDockerAvailable();
@@ -7758,6 +7900,26 @@ Start failed: ${result.error}`);
   }
   console.log("\nServer is running.");
 }
+async function updateCommand() {
+  assertDockerAvailable();
+  const cfg = readContainerConfig();
+  if (!cfg) {
+    console.error("No synkro-server container found. Run `synkro install` first.");
+    process.exit(1);
+  }
+  const claudeWorkers = cfg.claudeWorkers ?? 8;
+  const cursorWorkers = cfg.cursorWorkers ?? 0;
+  console.log("Synkro: updating to the latest container image");
+  console.log(`  preserving pool: ${claudeWorkers} claude + ${cursorWorkers} cursor worker(s)
+`);
+  await dockerUpdate({ claudeWorkers, cursorWorkers, connectedRepo: cfg.connectedRepo });
+  const ready = await waitForContainerReady(9e4);
+  if (!ready) {
+    console.error("\n\u26A0 container did not pass its health check within 90s \u2014 check: docker logs synkro-server");
+    process.exit(1);
+  }
+  console.log("\nSynkro updated \u2014 now running the latest version.");
+}
 async function restartCommand(rest = []) {
   assertDockerAvailable();
   const cfg = resolveWorkerConfig(rest);
@@ -7814,7 +7976,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.7");
 }
 function printHelp() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents
@@ -7824,10 +7986,11 @@ Usage:
 
 Commands:
   install [--force]      Install or update Synkro
-  uninstall [--purge]    Remove Synkro hooks (--purge also removes ~/.synkro)
+  uninstall [--purge]    Remove Synkro (keeps scan data; --purge wipes that too)
   stop                   Gracefully stop the server (snapshot + checkpoint)
   start [opts]           Start the server (with pgdata integrity check)
   restart [opts]         Safe restart (stop \u2192 start, data preserved)
+  update                 Pull the latest container image and safely restart
   version                Show version
 
   start/restart opts (recreate the worker pool):
@@ -7886,6 +8049,11 @@ async function main() {
       await restartCommand2(args.slice(1));
       break;
     }
+    case "update": {
+      const { updateCommand: updateCommand2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+      await updateCommand2();
+      break;
+    }
     default: {
       console.error(`Unknown command: ${cmd}`);
       printHelp();