@synkro-sh/cli 1.6.91 → 1.6.93

package/dist/bootstrap.js

@@ -1415,8 +1415,19 @@ export function loadSynkroFile(cwd?: string): SynkroFileConfig {
   }
 }
 
-export function effectiveGraderPool(synkroFile: SynkroFileConfig, hookAgentKind: AgentKind): AgentKind {
-  const pool = normalizePoolToken(synkroFile.grader.pool);
+export function effectiveGraderPool(synkroFile: SynkroFileConfig, hookAgentKind: AgentKind, config?: HookConfig): AgentKind {
+  // Source of truth for the pool SPLIT depends on grading location:
+  //   \u2022 cloud / byok \u2192 SERVER-managed (the user's dashboard choice, delivered as
+  //     config.graderPool from /v1/hook/config). synkro.toml isn't even written
+  //     for cloud installs, so it can't be the source there.
+  //   \u2022 local        \u2192 synkro.toml [grader] pool (on-device, user-owned).
+  // Falls back to synkro.toml whenever the server pool is absent, so a missing
+  // value never breaks grading \u2014 it just reverts to today's behavior.
+  const managed = process.env.SYNKRO_DEPLOY_LOCATION === 'cloud'
+    || (process.env.SYNKRO_GRADING_MODE || synkroFile.grader?.mode || config?.gradingMode) === 'byok';
+  const pool = (managed && config?.graderPool)
+    ? normalizePoolToken(config.graderPool)
+    : normalizePoolToken(synkroFile.grader.pool);
   if (pool === 'auto') return hookAgentKind;
   if (pool === 'claude') return 'claude_code';
   return 'cursor';
@@ -1517,6 +1528,11 @@ export interface HookConfig {
   // value from /v1/hook/config is only a fallback when the env var is unset.
   gradingMode: string;
   storageMode: string;
+  // Server-managed pool SPLIT (auto | claude | cursor) + canonical grading
+  // location, from /v1/hook/config. Authoritative ONLY for cloud/byok grading
+  // (synkro.toml governs local). Undefined when the gateway didn't report one.
+  graderPool?: string;
+  inferenceMode?: string;
 }
 
 /** True when telemetry + rules must stay on-machine (PGLite). Default: local. */
@@ -1597,6 +1613,9 @@ export async function loadConfig(jwt: string, query?: string): Promise<HookConfi
     config.silent = data.silent_mode === true || data.silent_mode === 'true';
     if (!process.env.SYNKRO_GRADING_MODE && data.grading_mode) config.gradingMode = data.grading_mode;
     if (!process.env.SYNKRO_STORAGE_MODE && data.storage_mode) config.storageMode = data.storage_mode;
+    // Server-managed pool split + location (cloud/byok only \u2014 see effectiveGraderPool).
+    if (data.grader_pool) config.graderPool = data.grader_pool;
+    if (data.inference_mode) config.inferenceMode = data.inference_mode;
     config.policyName = data.active_policy_name || '';
     if (Array.isArray(data.scan_exemptions)) {
       config.scanExemptions = data.scan_exemptions
@@ -4364,7 +4383,7 @@ async function main() {
     // Load config and decide route
     const config = await loadConfig(jwt);
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind, config);
     const rt = await route(config, synkroFile);
     const tagStr = tag(rt, config, graderPool);
 
@@ -4858,7 +4877,7 @@ async function main() {
 
     const config = await loadConfig(jwt);
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind, config);
     const rt = await cweRoute(config, synkroFile);
 
     // Combined-grade mode: the edit-precheck hook runs CWE inside its single
@@ -5586,7 +5605,7 @@ async function main() {
     const config = await loadConfig(jwt);
     const isCursor = isCursorHookFormat();
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, isCursor ? 'cursor' : 'claude_code');
+    const graderPool = effectiveGraderPool(synkroFile, isCursor ? 'cursor' : 'claude_code', config);
     const rt = await route(config, synkroFile);
     const tagStr = tag(rt, config, graderPool);
 
@@ -5768,7 +5787,7 @@ async function main() {
 
     const config = await loadConfig(jwt);
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, 'claude_code');
+    const graderPool = effectiveGraderPool(synkroFile, 'claude_code', config);
     const rt = await route(config, synkroFile);
     const tagStr = tag(rt, config, graderPool);
 
@@ -5777,35 +5796,14 @@ async function main() {
       return;
     }
 
-    if (isSafeInRepoRead(toolName, command, cwd)) {
-      log('bashGuard ' + cmdShort + ' → instant allow (safe in-repo read)');
-      appendLocalTelemetry({
-        capture_type: 'local_verdict',
-        verdict: 'pass',
-        hook_type: 'bash',
-        category: 'safe_read',
-        tool_name: toolName,
-        command: command.slice(0, 200),
-        session_id: sessionId,
-        repo: gitRepo || cwd,
-        cc_model: transcript.ccModel,
-        reasoning: 'Safe in-repo read — auto-allowed without an LLM grade.',
-      });
-      outputJson({
-        systemMessage: tagStr + ' bashGuard → pass: safe in-repo read',
-        hookSpecificOutput: {
-          hookEventName: 'PreToolUse',
-          additionalContext: tagStr + ' bashGuard pass: safe in-repo read.',
-        },
-      });
-      return;
-    }
-
     // ─── Secret firewall: BLOCK a literal credential in the command BEFORE it runs
     // or reaches the grader — the value never lands in a file, shell history, OR the
     // LLM provider (no leak to Anthropic/Cursor). Deterministic + local, no model
     // call. High-confidence formats only (a false block stops the user), and
-    // $VAR / placeholder refs never trip it. ───
+    // $VAR / placeholder refs never trip it. MUST run BEFORE the safe-read fast-path
+    // below — otherwise an echo/printf of a literal secret is treated as a safe read
+    // and waved through. A genuine read carries no literal secret, so this never
+    // false-blocks legitimate reads. ───
     const secretHits = detectHardSecrets(command);
     if (secretHits.length) {
       const types = secretHits.map(h => h.type).join(', ');
@@ -5830,6 +5828,32 @@ async function main() {
       return;
     }
 
+    // Safe in-repo read fast-path — runs AFTER the secret firewall above so a
+    // literal credential is never waved through as a "safe read".
+    if (isSafeInRepoRead(toolName, command, cwd)) {
+      log('bashGuard ' + cmdShort + ' → instant allow (safe in-repo read)');
+      appendLocalTelemetry({
+        capture_type: 'local_verdict',
+        verdict: 'pass',
+        hook_type: 'bash',
+        category: 'safe_read',
+        tool_name: toolName,
+        command: command.slice(0, 200),
+        session_id: sessionId,
+        repo: gitRepo || cwd,
+        cc_model: transcript.ccModel,
+        reasoning: 'Safe in-repo read — auto-allowed without an LLM grade.',
+      });
+      outputJson({
+        systemMessage: tagStr + ' bashGuard → pass: safe in-repo read',
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          additionalContext: tagStr + ' bashGuard pass: safe in-repo read.',
+        },
+      });
+      return;
+    }
+
     // ─── Install protection: install-scan runs first and owns block traces ───
     let scanConcern = '';
     let scanBlockContext = '';
@@ -6058,7 +6082,7 @@ async function main() {
 
     const config = await loadConfig(jwt);
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind, config);
     const rt = await route(config, synkroFile);
     const tagStr = tag(rt, config, graderPool);
 
@@ -6277,7 +6301,7 @@ async function main() {
 
     const config = await loadConfig(jwt);
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind, config);
     const rt = await route(config, synkroFile);
     const tagStr = tag(rt, config, graderPool);
 
@@ -6513,12 +6537,15 @@ async function main() {
       return;
     }
 
-    // Sync grading mode to API profile so the dashboard reflects the actual config
-    const fastInference = gradingMode === 'byok';
+    // Sync the canonical 3-state grading location to the API profile so the
+    // dashboard reflects the machine's ACTUAL config. byok (own API key) wins;
+    // else the cloud worker pool; else on-device workers. The API derives the
+    // legacy fast_inference boolean from this, so we only send one field.
+    const inferenceMode = gradingMode === 'byok' ? 'byok' : (deployCloud ? 'cloud' : 'local');
     fetch(GATEWAY_URL + '/api/v1/cli/me', {
       method: 'PATCH',
       headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + jwt },
-      body: JSON.stringify({ fast_inference: fastInference }),
+      body: JSON.stringify({ inference_mode: inferenceMode }),
       signal: AbortSignal.timeout(3000),
     }).catch(() => {});
 
@@ -6850,6 +6877,25 @@ async function main() {
 
     // Instant-allow read-only tool calls + safe in-repo bash reads \u2014 no grade,
     // no network. Critical under Cursor's tight 15s beforeShellExecution budget.
+    // \u2500\u2500\u2500 Secret firewall: BLOCK a literal credential in the command BEFORE it runs
+    // or reaches the grader \u2014 never leaks to a file, shell history, or the model
+    // (Anthropic/Cursor). Local + deterministic; $VAR / placeholder refs never trip
+    // it. MUST run BEFORE the safe-read fast-path below \u2014 else an echo/printf of a
+    // literal secret is waved through as a "safe read". \u2500\u2500\u2500
+    const secretHits = detectHardSecrets(command);
+    if (secretHits.length) {
+      const types = secretHits.map(h => h.type).join(', ');
+      const remediation = secretRemediation(command, secretHits);
+      log('bashGuard ' + cmdShort + ' \u2192 BLOCKED: literal credential (' + types + ')');
+      appendLocalTelemetry({
+        capture_type: 'local_verdict', verdict: 'block', hook_type: 'bash',
+        category: 'secret_exposure', tool_name: toolName, command: scrubSecrets(command).slice(0, 200),
+        session_id: sessionId, repo: repo || cwd, cc_model: model,
+        reasoning: 'Literal credential (' + types + ') in the proposed command \u2014 blocked locally before grading; never sent to the model.',
+      });
+      finishWith({ permission: 'deny', user_message: '[synkro] bashGuard \u2192 BLOCKED: literal credential in command (' + types + '). Use an env var reference instead.', agent_message: remediation });
+    }
+
     if (isSafeInRepoRead(toolName, command, cwd)) {
       log('bashGuard ' + cmdShort + ' \u2192 instant allow (safe in-repo read)');
       appendLocalTelemetry({
@@ -6873,27 +6919,10 @@ async function main() {
     if (config.silent) finishAllow();
 
     const synkroFile = loadSynkroFile(cwd);
-    const graderPool = effectiveGraderPool(synkroFile, 'cursor');
+    const graderPool = effectiveGraderPool(synkroFile, 'cursor', config);
     const rt = await route(config, synkroFile);
     const tagStr = tag(rt, config, graderPool);
 
-    // Secret firewall: BLOCK a literal credential in the command BEFORE it runs or
-    // reaches the grader \u2014 never leaks to a file, shell history, or the model
-    // (Anthropic/Cursor). Local + deterministic; $VAR / placeholder refs never trip it.
-    const secretHits = detectHardSecrets(command);
-    if (secretHits.length) {
-      const types = secretHits.map(h => h.type).join(', ');
-      const remediation = secretRemediation(command, secretHits);
-      log('bashGuard ' + cmdShort + ' \u2192 BLOCKED: literal credential (' + types + ')');
-      appendLocalTelemetry({
-        capture_type: 'local_verdict', verdict: 'block', hook_type: 'bash',
-        category: 'secret_exposure', tool_name: toolName, command: scrubSecrets(command).slice(0, 200),
-        session_id: sessionId, repo: repo || cwd, cc_model: model,
-        reasoning: 'Literal credential (' + types + ') in the proposed command \u2014 blocked locally before grading; never sent to the model.',
-      });
-      finishWith({ permission: 'deny', user_message: tagStr + ' bashGuard \u2192 BLOCKED: literal credential in command (' + types + '). Use an env var reference instead.', agent_message: remediation });
-    }
-
     // Install protection \u2014 install-scan runs first and owns block traces.
     let scanConcern = '';
     let scanBlockContext = '';
@@ -11208,7 +11237,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.6.91")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.6.93")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -15115,6 +15144,11 @@ function updateConfigValue(key, value) {
   if (!found) updated.splice(updated.length - 1, 0, `${key}='${value}'`);
   writeFileSync13(CONFIG_PATH6, updated.join("\n"), "utf-8");
 }
+function resolveInferenceMode(cfg) {
+  if ((cfg.SYNKRO_GRADING_MODE || "local") === "byok") return "byok";
+  if (cfg.SYNKRO_DEPLOY_LOCATION === "cloud") return "cloud";
+  return "local";
+}
 async function reconcileContainer() {
   const cfg = readConfigEnv2();
   const cloudOnly = (cfg.SYNKRO_GRADING_MODE || "local") === "byok" && (cfg.SYNKRO_STORAGE_MODE || "local") === "cloud";
@@ -15142,17 +15176,18 @@ async function configCommand(args2) {
   if (args2.length === 0) {
     const config2 = readConfigEnv2();
     console.log("Synkro config:\n");
-    console.log(`  grading:    ${config2.SYNKRO_GRADING_MODE || "local"}`);
+    console.log(`  inference:  ${resolveInferenceMode(config2)}`);
     console.log(`  storage:    ${config2.SYNKRO_STORAGE_MODE || "local"}`);
-    console.log(`  inference:  ${config2.SYNKRO_INFERENCE || "fast"}`);
     console.log(`  tier:       ${config2.SYNKRO_TIER || "pro"}`);
     console.log(`  gateway:    ${config2.SYNKRO_GATEWAY_URL || "https://api.synkro.sh"}`);
     console.log(`  version:    ${config2.SYNKRO_VERSION || "?"}`);
     console.log(`
 To change:`);
-    console.log(`  synkro config grading <local|byok>    \u2014 where grading runs`);
-    console.log(`  synkro config storage <local|cloud>   \u2014 where telemetry is stored`);
-    console.log(`  synkro config --inference fast|standard`);
+    console.log(`  synkro config --inference <local|cloud|byok>  \u2014 where grading runs`);
+    console.log(`      local  \u2014 Claude/Cursor workers on this machine (your subscription)`);
+    console.log(`      cloud  \u2014 Claude/Cursor workers in the Synkro cloud pool`);
+    console.log(`      byok   \u2014 graded via your own provider API key`);
+    console.log(`  synkro config storage <local|cloud>           \u2014 where telemetry is stored`);
     return;
   }
   if (args2[0] === "grading") {
@@ -15186,8 +15221,8 @@ To change:`);
     if (a.startsWith("--inference=")) inferenceValue = a.slice("--inference=".length);
     else if (a === "--inference" && args2.indexOf(a) + 1 < args2.length) inferenceValue = args2[args2.indexOf(a) + 1];
   }
-  if (!inferenceValue || !["fast", "standard"].includes(inferenceValue)) {
-    console.error("Usage: synkro config --inference fast|standard");
+  if (!inferenceValue || !["local", "cloud", "byok"].includes(inferenceValue)) {
+    console.error("Usage: synkro config --inference <local|cloud|byok>");
     process.exit(1);
   }
   if (!isAuthenticated()) {
@@ -15204,7 +15239,7 @@ To change:`);
         "Authorization": `Bearer ${token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ fast_inference: inferenceValue === "fast" })
+      body: JSON.stringify({ inference_mode: inferenceValue })
     });
     if (!resp.ok) {
       const errText = await resp.text().catch(() => "");
@@ -15215,8 +15250,24 @@ To change:`);
     console.error(`Failed to reach server: ${err.message}`);
     process.exit(1);
   }
-  updateConfigValue("SYNKRO_INFERENCE", inferenceValue);
+  if (inferenceValue === "byok") {
+    updateConfigValue("SYNKRO_GRADING_MODE", "byok");
+    updateConfigValue("SYNKRO_DEPLOY_LOCATION", "local");
+  } else if (inferenceValue === "cloud") {
+    updateConfigValue("SYNKRO_GRADING_MODE", "local");
+    updateConfigValue("SYNKRO_DEPLOY_LOCATION", "cloud");
+  } else {
+    updateConfigValue("SYNKRO_GRADING_MODE", "local");
+    updateConfigValue("SYNKRO_DEPLOY_LOCATION", "local");
+  }
   console.log(`\u2713 Inference set to '${inferenceValue}'.`);
+  if (inferenceValue === "byok") {
+    console.log("  BYOK grading uses your own provider key \u2014 register one in the");
+    console.log("  dashboard under Settings \u2192 Provider Keys if you have not already.");
+  } else if (inferenceValue === "cloud") {
+    console.log("  Grading runs on the Synkro cloud worker pool (containers.synkro.sh).");
+  }
+  if (inferenceValue !== "cloud") await reconcileContainer();
 }
 var SYNKRO_DIR7, CONFIG_PATH6;
 var init_config = __esm({
@@ -15251,7 +15302,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.6.91");
+  console.log("1.6.93");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents