calllint 1.7.1 → 1.7.2

package/README.md

@@ -64,6 +64,9 @@ will do, it says so and never silently upgrades to `SAFE`.
 - Self-contained HTML report: `calllint scan <config> --html > report.html`
 - Drift / rug-pull detection: `calllint baseline <config>` then `calllint verify <config> --ci`
 - Policy-as-code: `calllint policy init`
+- Continuous Guard: `calllint guard` re-decides the approved authority surface (silent when unchanged); `calllint guard install --host <git|git-pre-push|github|claude-code|copilot|gemini|vscode>` adds a session-start / commit / CI hook that only shells out to `calllint guard` — never a per-call blocker
+- Install the preflight into your hosts: `calllint integrate` prints a reversible install plan (writes nothing); `--apply --approve <digest>` is the only writer and reuses the audited atomic-write-and-rollback engine
+- Claude Code plugin: a `PreToolUse` hook that *recommends* scanning before an agent-tool config edit — advisory, non-blocking, always exits 0, runs no scan itself
 
 CallLint is a heuristic, evidence-backed pre-flight check, **not a proof of
 safety**. `No blockers observed` ≠ guaranteed safe. Full docs, security model,

package/dist/index.js

@@ -5510,7 +5510,7 @@ function scanOneConfig(text, configPath, policy, args, deps, allowReceipt = true
     if (err2) return { stdout: "", stderr: err2, exitCode: EXIT.ERROR };
   }
   const exitCode = flagBool(args.flags, "ci") ? exitCodeFor(summary, policy) : EXIT.OK;
-  return { stdout, exitCode };
+  return { stdout, exitCode, telemetry: { verdict: summary.verdict } };
 }
 function writeReceiptFile(summary, text, configPath, policy, args, deps) {
   const toolVersion = deps.toolVersion ?? "0.0.0-dev";
@@ -8985,11 +8985,63 @@ function windsurfServerEntry(server) {
   return entry;
 }
 
+// ../../packages/install-planner/src/adapters/claudeDesktop.ts
+var CLAUDE_DESKTOP_HOST_ID = "claude-desktop";
+var CLAUDE_DESKTOP_TIER = "A";
+var claudeDesktopAdapter = {
+  id: CLAUDE_DESKTOP_HOST_ID,
+  tier: CLAUDE_DESKTOP_TIER,
+  createPlan(ctx, upstream) {
+    return buildInstallPlan({ ...ctx, host: CLAUDE_DESKTOP_HOST_ID, tier: CLAUDE_DESKTOP_TIER }, upstream);
+  },
+  validatePlan(plan) {
+    return validatePlan(plan);
+  },
+  applyPlan(plan, ctx) {
+    return applyPlan({
+      plan,
+      approvalDigest: ctx.approvalDigest,
+      configPath: ctx.configPath,
+      backupPath: ctx.backupPath,
+      lockPath: ctx.lockPath,
+      fs: ctx.fs,
+      now: ctx.now
+    });
+  }
+};
+
+// ../../packages/install-planner/src/adapters/vscode.ts
+var VSCODE_HOST_ID = "vscode";
+var VSCODE_TIER = "A";
+var vscodeAdapter = {
+  id: VSCODE_HOST_ID,
+  tier: VSCODE_TIER,
+  createPlan(ctx, upstream) {
+    return buildInstallPlan({ ...ctx, host: VSCODE_HOST_ID, tier: VSCODE_TIER }, upstream);
+  },
+  validatePlan(plan) {
+    return validatePlan(plan);
+  },
+  applyPlan(plan, ctx) {
+    return applyPlan({
+      plan,
+      approvalDigest: ctx.approvalDigest,
+      configPath: ctx.configPath,
+      backupPath: ctx.backupPath,
+      lockPath: ctx.lockPath,
+      fs: ctx.fs,
+      now: ctx.now
+    });
+  }
+};
+
 // ../../packages/install-planner/src/index.ts
 var HOST_ADAPTERS = {
   [claudeCodeAdapter.id]: claudeCodeAdapter,
   [cursorAdapter.id]: cursorAdapter,
-  [windsurfAdapter.id]: windsurfAdapter
+  [windsurfAdapter.id]: windsurfAdapter,
+  [claudeDesktopAdapter.id]: claudeDesktopAdapter,
+  [vscodeAdapter.id]: vscodeAdapter
 };
 function getHostAdapter(host) {
   return HOST_ADAPTERS[host] ?? null;
@@ -10495,8 +10547,192 @@ function usage(msg) {
   return { stdout: "", stderr: msg, exitCode: EXIT.USAGE };
 }
 
+// ../../packages/telemetry-contract/src/events.ts
+var ALLOWED_EVENTS = [
+  "install_completed",
+  "preflight_completed",
+  "decision_safe",
+  "decision_review",
+  "decision_block",
+  "decision_unknown",
+  "approval_created",
+  "apply_completed",
+  "verify_completed",
+  "rollback_completed",
+  "guard_drift_detected",
+  "trust_page_viewed",
+  "trust_page_to_install",
+  "partner_api_called",
+  "badge_rendered"
+];
+var FORBIDDEN_FIELDS = [
+  "rawConfig",
+  "command",
+  "environmentValue",
+  "secret",
+  "fileContents",
+  "privateRepository",
+  "userPrompt",
+  "findingEvidenceText"
+];
+var SOURCES = ["cli", "ci", "server", "install"];
+var RESULTS2 = ["SAFE", "REVIEW", "BLOCK", "UNKNOWN"];
+var EVENT_VERSION = "1.0.0";
+
+// ../../packages/telemetry-contract/src/tiers.ts
+var TIER_POLICY = {
+  server: {
+    source: "server",
+    defaultEnabled: true,
+    requiresNotice: false,
+    rationale: "Own web/API property; no user machine involved (funnel top)."
+  },
+  install: {
+    source: "install",
+    defaultEnabled: true,
+    requiresNotice: false,
+    rationale: "Attributed at the click/redirect surface, not on the machine."
+  },
+  ci: {
+    source: "ci",
+    defaultEnabled: true,
+    requiresNotice: true,
+    rationale: "The installing org is the controller; standard for CI tooling; disableable."
+  },
+  cli: {
+    source: "cli",
+    defaultEnabled: false,
+    requiresNotice: true,
+    rationale: "Personal machine \u2192 consent-first (opt-in, default off, first-run consent)."
+  }
+};
+function isEnabledByDefault(source) {
+  return TIER_POLICY[source].defaultEnabled;
+}
+
+// ../../packages/telemetry-contract/src/sanitize.ts
+function bucketDuration(ms) {
+  if (ms == null || !Number.isFinite(ms) || ms < 0) return void 0;
+  if (ms < 100) return "<100ms";
+  if (ms < 500) return "100-500ms";
+  if (ms < 2e3) return "500-2000ms";
+  return ">2000ms";
+}
+var isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+function sanitizeEvent(input) {
+  for (const f of FORBIDDEN_FIELDS) {
+    if (f in input) {
+      throw new Error(`telemetry: forbidden field "${f}" present on event \u2014 refusing to sanitize`);
+    }
+  }
+  if (!ALLOWED_EVENTS.includes(input.eventName)) {
+    throw new Error(`telemetry: unknown eventName "${input.eventName}"`);
+  }
+  if (!SOURCES.includes(input.source)) {
+    throw new Error(`telemetry: unknown source "${input.source}"`);
+  }
+  if (input.result != null && !RESULTS2.includes(input.result)) {
+    throw new Error(`telemetry: unknown result "${input.result}"`);
+  }
+  const out = {
+    eventVersion: EVENT_VERSION,
+    eventName: input.eventName,
+    timestamp: isNonEmptyString(input.timestamp) ? input.timestamp : "",
+    source: input.source
+  };
+  if (isNonEmptyString(input.hostFamily)) out.hostFamily = input.hostFamily;
+  if (input.result != null) out.result = input.result;
+  const bucket = bucketDuration(input.durationMs);
+  if (bucket) out.durationBucket = bucket;
+  if (isNonEmptyString(input.inputKind)) out.inputKind = input.inputKind;
+  if (isNonEmptyString(input.anonymousInstallationId)) {
+    out.anonymousInstallationId = input.anonymousInstallationId;
+  }
+  if (isNonEmptyString(input.productVersion)) out.productVersion = input.productVersion;
+  return out;
+}
+
+// ../../packages/telemetry-emit/src/gate.ts
+var DISABLED_VALUES = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+function isTelemetryDisabledByEnv(env) {
+  const v = env["CALLLINT_TELEMETRY"];
+  return v != null && DISABLED_VALUES.has(v.trim().toLowerCase());
+}
+function shouldEmit(source, state = {}) {
+  const env = state.env ?? {};
+  if (isTelemetryDisabledByEnv(env)) return false;
+  if (source === "cli") return state.consented === true;
+  return isEnabledByDefault(source);
+}
+
+// ../../packages/telemetry-emit/src/sink.ts
+var noopSink = {
+  kind: "noop",
+  write() {
+  }
+};
+
+// ../../packages/telemetry-emit/src/emitter.ts
+function createEmitter(config) {
+  const sink = config.sink ?? noopSink;
+  const gate = { consented: config.consented, env: config.env };
+  return {
+    source: config.source,
+    emit(input) {
+      if (!shouldEmit(config.source, gate)) {
+        return { status: "gated", reason: "disabled-or-no-consent" };
+      }
+      let event;
+      try {
+        event = sanitizeEvent({ ...input, source: config.source });
+      } catch (err2) {
+        return { status: "dropped", reason: err2 instanceof Error ? err2.message : String(err2) };
+      }
+      sink.write(event);
+      return { status: "emitted", event };
+    }
+  };
+}
+
+// src/telemetry.ts
+var VERDICT_EVENT = {
+  SAFE: "decision_safe",
+  REVIEW: "decision_review",
+  BLOCK: "decision_block",
+  UNKNOWN: "decision_unknown"
+};
+function eventFor(signal) {
+  if (signal.event) return signal.event;
+  if (signal.verdict) return VERDICT_EVENT[signal.verdict];
+  return null;
+}
+function buildCliEmitter(env, opts = {}) {
+  return createEmitter({ source: "cli", env, sink: opts.sink, consented: opts.consented });
+}
+function emitCommandSignal(emitter, signal, productVersion) {
+  if (!emitter || !signal) return;
+  try {
+    const eventName = eventFor(signal);
+    if (!eventName) return;
+    const input = {
+      eventName,
+      ...signal.verdict ? { result: signal.verdict } : {},
+      ...signal.hostFamily ? { hostFamily: signal.hostFamily } : {},
+      ...signal.inputKind ? { inputKind: signal.inputKind } : {},
+      ...productVersion ? { productVersion } : {}
+    };
+    emitter.emit(input);
+  } catch {
+  }
+}
+
 // src/run.ts
 function run(argv, deps) {
+  const result = dispatch(argv, deps);
+  emitCommandSignal(deps.emitter, result.telemetry, deps.toolVersion);
+  return result;
+}
+function dispatch(argv, deps) {
   const args = parseArgs(argv);
   const cmd = args.command;
   if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
@@ -10914,6 +11150,7 @@ async function main() {
     await breathe(argv);
   } catch {
   }
+  const emitter = buildCliEmitter(process.env);
   const result = run(argv, {
     cwd: process.cwd(),
     readStdin,
@@ -10921,7 +11158,8 @@ async function main() {
     generatedAt,
     online,
     toolVersion: resolveToolVersion(),
-    getChangedFilesDiff: () => gitChangedFiles(process.cwd())
+    getChangedFilesDiff: () => gitChangedFiles(process.cwd()),
+    emitter
   });
   if (result.stdout) process.stdout.write(result.stdout + "\n");
   if (result.stderr) process.stderr.write(result.stderr + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calllint",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Evidence-backed security verdicts for MCP servers and agent tools. Lint agent tool-call risk before tools run — SAFE / REVIEW / BLOCK / UNKNOWN, with evidence. Never executes the server it judges.",
   "keywords": [
     "mcp",
@@ -63,6 +63,8 @@
     "@calllint/report-renderer": "workspace:*",
     "@calllint/resolver": "workspace:*",
     "@calllint/signature": "workspace:*",
+    "@calllint/telemetry-contract": "workspace:*",
+    "@calllint/telemetry-emit": "workspace:*",
     "@calllint/types": "workspace:*",
     "esbuild": "^0.21.5"
   }