@cdot65/prisma-airs-cursor-hooks 0.1.0

package/dist/scanner.js

@@ -0,0 +1,298 @@
+import { scanPromptContent, scanResponseContent, AISecSDKException, } from "./airs-client.js";
+import { extractCode, joinCodeBlocks } from "./code-extractor.js";
+import { getEnforcementAction, DEFAULT_ENFORCEMENT } from "./dlp-masking.js";
+// ---------------------------------------------------------------------------
+// Human-readable detection labels for UX messages
+// ---------------------------------------------------------------------------
+const DETECTION_LABELS = {
+    prompt_injection: "Prompt Injection",
+    dlp: "Data Loss Prevention (DLP)",
+    toxicity: "Toxic Content",
+    url_categorization: "Suspicious URL",
+    malicious_code: "Malicious Code",
+    custom_topic: "Topic Policy Violation",
+};
+function friendlyDetectionName(key) {
+    return DETECTION_LABELS[key] ?? key;
+}
+function extractDetections(result) {
+    const services = [];
+    const findings = [];
+    const pd = result.prompt_detected;
+    if (pd) {
+        if (pd.injection) {
+            services.push("prompt_injection");
+            findings.push({ detection_service: "prompt_injection", verdict: "malicious", detail: "Prompt injection detected" });
+        }
+        if (pd.dlp) {
+            services.push("dlp");
+            findings.push({ detection_service: "dlp", verdict: "detected", detail: "Sensitive data detected in prompt" });
+        }
+        if (pd.toxic_content) {
+            services.push("toxicity");
+            findings.push({ detection_service: "toxicity", verdict: "toxic", detail: "Toxic content detected" });
+        }
+        if (pd.url_cats) {
+            services.push("url_categorization");
+            findings.push({ detection_service: "url_categorization", verdict: "suspicious", detail: "Suspicious URL detected" });
+        }
+        if (pd.malicious_code) {
+            services.push("malicious_code");
+            findings.push({ detection_service: "malicious_code", verdict: "malicious", detail: "Malicious code detected" });
+        }
+        if (pd.topic_violation) {
+            services.push("custom_topic");
+            findings.push({ detection_service: "custom_topic", verdict: "violation", detail: "Topic policy violation" });
+        }
+    }
+    const rd = result.response_detected;
+    if (rd) {
+        if (rd.malicious_code) {
+            services.push("malicious_code");
+            findings.push({ detection_service: "malicious_code", verdict: "malicious", detail: "Malicious code detected in response" });
+        }
+        if (rd.dlp) {
+            services.push("dlp");
+            findings.push({ detection_service: "dlp", verdict: "detected", detail: "Sensitive data detected in response" });
+        }
+        if (rd.toxic_content) {
+            services.push("toxicity");
+            findings.push({ detection_service: "toxicity", verdict: "toxic", detail: "Toxic content in response" });
+        }
+        if (rd.url_cats) {
+            services.push("url_categorization");
+            findings.push({ detection_service: "url_categorization", verdict: "suspicious", detail: "Suspicious URL in response" });
+        }
+    }
+    return { services, findings };
+}
+// ---------------------------------------------------------------------------
+// Resolve the developer's identity
+// Cursor provides CURSOR_USER_EMAIL; fall back to git config then OS user.
+// ---------------------------------------------------------------------------
+function getAppUser() {
+    const cursorEmail = process.env.CURSOR_USER_EMAIL;
+    if (cursorEmail)
+        return cursorEmail;
+    try {
+        const { execSync } = require("node:child_process");
+        return execSync("git config user.email", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return process.env.USER ?? process.env.USERNAME ?? "unknown";
+    }
+}
+// ---------------------------------------------------------------------------
+// Build UX-friendly block messages
+// ---------------------------------------------------------------------------
+function buildPromptBlockMessage(detections, category, profileName, scanId) {
+    const detectionList = detections.map(friendlyDetectionName).join(", ");
+    return [
+        "",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "  Prisma AIRS — Prompt Blocked",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+        `  What happened:  Your prompt was flagged by the ${detectionList} security check.`,
+        `  Category:       ${category}`,
+        `  Profile:        ${profileName}`,
+        "",
+        "  What to do:",
+        "    - Review your prompt for sensitive data, injection patterns, or policy violations.",
+        "    - Modify the prompt and try again.",
+        "    - If you believe this is a false positive, contact your security team",
+        `      and reference Scan ID: ${scanId}`,
+        "",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+    ].join("\n");
+}
+function buildResponseBlockMessage(detections, category, profileName, scanId) {
+    const detectionList = detections.map(friendlyDetectionName).join(", ");
+    return [
+        "",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "  Prisma AIRS — Response Blocked",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+        `  What happened:  The AI response was flagged by the ${detectionList} security check.`,
+        `  Category:       ${category}`,
+        `  Profile:        ${profileName}`,
+        "",
+        "  What to do:",
+        "    - The response may have contained malicious code, sensitive data, or unsafe content.",
+        "    - Try rephrasing your original prompt to get a different response.",
+        "    - If you believe this is a false positive, contact your security team",
+        `      and reference Scan ID: ${scanId}`,
+        "",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+    ].join("\n");
+}
+function buildMaskedMessage(maskedServices) {
+    const names = maskedServices.map(friendlyDetectionName).join(", ");
+    return [
+        "",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "  Prisma AIRS — Sensitive Data Masked",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+        `  ${names} detected sensitive data in your content.`,
+        "  The flagged patterns have been masked with asterisks.",
+        "",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+    ].join("\n");
+}
+// ---------------------------------------------------------------------------
+// scanPrompt — called by beforeSubmitPrompt hook
+// ---------------------------------------------------------------------------
+export async function scanPrompt(config, prompt, logger) {
+    if (config.mode === "bypass") {
+        logger.logEvent("scan_bypassed", { direction: "prompt" });
+        return { action: "pass" };
+    }
+    if (!prompt.trim()) {
+        return { action: "pass" };
+    }
+    const appUser = getAppUser();
+    try {
+        const { result, latencyMs } = await scanPromptContent(config, prompt, appUser, logger);
+        const verdict = result.action === "block" ? "block" : "allow";
+        const { services: detections, findings } = extractDetections(result);
+        const actionTaken = config.mode === "observe"
+            ? "observed"
+            : verdict === "block"
+                ? "blocked"
+                : "allowed";
+        logger.logScan({
+            event: "scan_complete",
+            scan_id: result.scan_id ?? "",
+            direction: "prompt",
+            verdict: verdict,
+            action_taken: actionTaken,
+            latency_ms: latencyMs,
+            detection_services_triggered: detections,
+            error: null,
+        });
+        if (config.mode === "enforce" && verdict === "block") {
+            // Check per-service enforcement — some services may be set to "mask" or "allow"
+            const enforcement = config.enforcement ?? DEFAULT_ENFORCEMENT;
+            const enforcementAction = getEnforcementAction(findings, enforcement);
+            if (enforcementAction === "allow") {
+                return { action: "pass" };
+            }
+            if (enforcementAction === "mask") {
+                // DLP masking: we can't mask prompt content that's already been sent,
+                // but we log it and warn the user
+                const maskedServices = findings
+                    .filter((f) => (enforcement[f.detection_service] ?? "block") === "mask")
+                    .map((f) => f.detection_service);
+                logger.logEvent("dlp_mask_applied", { direction: "prompt", services: maskedServices });
+                return { action: "pass", message: buildMaskedMessage(maskedServices) };
+            }
+            return {
+                action: "block",
+                message: buildPromptBlockMessage(detections, result.category ?? "policy violation", config.profiles.prompt, result.scan_id ?? "unknown"),
+            };
+        }
+        return { action: "pass" };
+    }
+    catch (err) {
+        const isAuth = err instanceof AISecSDKException && err.message.includes("401");
+        const message = isAuth
+            ? "AIRS authentication failed. Check your API key."
+            : "AIRS scan failed — allowing prompt (fail-open)";
+        logger.logScan({
+            event: "scan_error",
+            scan_id: "",
+            direction: "prompt",
+            verdict: "allow",
+            action_taken: "error",
+            latency_ms: 0,
+            detection_services_triggered: [],
+            error: message,
+        });
+        if (isAuth) {
+            return { action: "pass", message: `Warning: ${message}` };
+        }
+        return { action: "pass" };
+    }
+}
+// ---------------------------------------------------------------------------
+// scanResponse — called by afterAgentResponse hook
+// ---------------------------------------------------------------------------
+export async function scanResponse(config, responseText, logger) {
+    if (config.mode === "bypass") {
+        logger.logEvent("scan_bypassed", { direction: "response" });
+        return { action: "pass" };
+    }
+    if (!responseText.trim()) {
+        return { action: "pass" };
+    }
+    const appUser = getAppUser();
+    const extracted = extractCode(responseText);
+    const codeResponse = extracted.codeBlocks.length > 0
+        ? joinCodeBlocks(extracted.codeBlocks)
+        : undefined;
+    const nlText = codeResponse ? extracted.naturalLanguage : responseText;
+    try {
+        const { result, latencyMs } = await scanResponseContent(config, nlText, codeResponse, appUser, logger);
+        const verdict = result.action === "block" ? "block" : "allow";
+        const { services: detections, findings } = extractDetections(result);
+        const actionTaken = config.mode === "observe"
+            ? "observed"
+            : verdict === "block"
+                ? "blocked"
+                : "allowed";
+        logger.logScan({
+            event: "scan_complete",
+            scan_id: result.scan_id ?? "",
+            direction: "response",
+            verdict: verdict,
+            action_taken: actionTaken,
+            latency_ms: latencyMs,
+            detection_services_triggered: detections,
+            error: null,
+        });
+        if (config.mode === "enforce" && verdict === "block") {
+            const enforcement = config.enforcement ?? DEFAULT_ENFORCEMENT;
+            const enforcementAction = getEnforcementAction(findings, enforcement);
+            if (enforcementAction === "allow") {
+                return { action: "pass" };
+            }
+            if (enforcementAction === "mask") {
+                const maskedServices = findings
+                    .filter((f) => (enforcement[f.detection_service] ?? "block") === "mask")
+                    .map((f) => f.detection_service);
+                logger.logEvent("dlp_mask_applied", { direction: "response", services: maskedServices });
+                return { action: "pass", message: buildMaskedMessage(maskedServices) };
+            }
+            return {
+                action: "block",
+                message: buildResponseBlockMessage(detections, result.category ?? "policy violation", config.profiles.response, result.scan_id ?? "unknown"),
+            };
+        }
+        return { action: "pass" };
+    }
+    catch (err) {
+        const isAuth = err instanceof AISecSDKException && err.message.includes("401");
+        const message = isAuth
+            ? "AIRS authentication failed. Check your API key."
+            : "AIRS scan failed — allowing response (fail-open)";
+        logger.logScan({
+            event: "scan_error",
+            scan_id: "",
+            direction: "response",
+            verdict: "allow",
+            action_taken: "error",
+            latency_ms: 0,
+            detection_services_triggered: [],
+            error: message,
+        });
+        if (isAuth) {
+            return { action: "pass", message: `Warning: ${message}` };
+        }
+        return { action: "pass" };
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@cdot65/prisma-airs-cursor-hooks",
+  "version": "0.1.0",
+  "description": "Cursor IDE hooks integrating Prisma AIRS scanning into the developer workflow",
+  "type": "module",
+  "keywords": [
+    "cursor",
+    "cursor-hooks",
+    "prisma",
+    "airs",
+    "ai-security",
+    "prompt-injection",
+    "dlp",
+    "malicious-code",
+    "palo-alto"
+  ],
+  "author": "cdot65",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cdot65/prisma-airs-cursor-hooks.git"
+  },
+  "homepage": "https://cdot65.github.io/prisma-airs-cursor-hooks/",
+  "bugs": {
+    "url": "https://github.com/cdot65/prisma-airs-cursor-hooks/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "prisma-airs-hooks": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "scripts/",
+    "airs-config.json",
+    "tsconfig.build.json",
+    "src/"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "validate-connection": "tsx scripts/validate-connection.ts",
+    "validate-detection": "tsx scripts/validate-detection.ts",
+    "install-hooks": "tsx scripts/install-hooks.ts",
+    "uninstall-hooks": "tsx scripts/uninstall-hooks.ts",
+    "verify-hooks": "tsx scripts/verify-hooks.ts",
+    "stats": "tsx scripts/airs-stats.ts",
+    "docs:serve": "mkdocs serve",
+    "docs:build": "mkdocs build"
+  },
+  "dependencies": {
+    "@cdot65/prisma-airs-sdk": "^0.6.7",
+    "tsx": "^4.19.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.1.0"
+  }
+}

package/scripts/airs-stats.ts

@@ -0,0 +1,119 @@
+#!/usr/bin/env tsx
+/**
+ * Display scan statistics from the AIRS log file.
+ * Run: npx tsx scripts/airs-stats.ts [--since 24h] [--json]
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+interface LogEntry {
+  timestamp: string;
+  event: string;
+  scan_id?: string;
+  direction?: string;
+  verdict?: string;
+  action_taken?: string;
+  latency_ms?: number;
+  detection_services_triggered?: string[];
+  error?: string | null;
+}
+
+function parseSince(arg: string): number {
+  const match = arg.match(/^(\d+)(h|d|m)$/);
+  if (!match) return 24 * 60 * 60 * 1000; // default 24h
+  const val = parseInt(match[1]);
+  const unit = match[2];
+  const multipliers: Record<string, number> = { m: 60_000, h: 3_600_000, d: 86_400_000 };
+  return val * (multipliers[unit] ?? 3_600_000);
+}
+
+function percentile(sorted: number[], p: number): number {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil((p / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const jsonOutput = args.includes("--json");
+  const sinceIdx = args.indexOf("--since");
+  const sinceMs = sinceIdx >= 0 ? parseSince(args[sinceIdx + 1]) : 24 * 60 * 60 * 1000;
+
+  const logPath = resolve(process.cwd(), ".cursor", "hooks", "airs-scan.log");
+  if (!existsSync(logPath)) {
+    console.log("No log file found at", logPath);
+    process.exit(0);
+  }
+
+  const cutoff = new Date(Date.now() - sinceMs).toISOString();
+  const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+  const entries: LogEntry[] = lines
+    .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+    .filter((e): e is LogEntry => e !== null && e.timestamp >= cutoff);
+
+  const scans = entries.filter((e) => e.event === "scan_complete");
+  const prompts = scans.filter((e) => e.direction === "prompt");
+  const responses = scans.filter((e) => e.direction === "response");
+
+  const allowed = scans.filter((e) => e.action_taken === "allowed" || e.action_taken === "observed").length;
+  const blocked = scans.filter((e) => e.action_taken === "blocked").length;
+  const observed = scans.filter((e) => e.action_taken === "observed").length;
+  const errors = scans.filter((e) => e.action_taken === "error" || e.action_taken === "bypassed").length;
+
+  const detections: Record<string, number> = {};
+  for (const s of scans) {
+    for (const d of s.detection_services_triggered ?? []) {
+      detections[d] = (detections[d] ?? 0) + 1;
+    }
+  }
+
+  const latencies = scans.map((s) => s.latency_ms ?? 0).sort((a, b) => a - b);
+
+  const stats = {
+    total: scans.length,
+    prompts: prompts.length,
+    responses: responses.length,
+    allowed,
+    blocked,
+    observed,
+    errors,
+    detections,
+    latency: {
+      p50: percentile(latencies, 50),
+      p95: percentile(latencies, 95),
+      p99: percentile(latencies, 99),
+    },
+  };
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(stats, null, 2));
+    return;
+  }
+
+  const pct = (n: number) => scans.length > 0 ? ((n / scans.length) * 100).toFixed(1) : "0.0";
+
+  console.log(`Prisma AIRS Hook Statistics`);
+  console.log(`${"─".repeat(45)}`);
+  console.log(`Total scans:        ${stats.total}`);
+  console.log(`Prompts scanned:    ${stats.prompts}`);
+  console.log(`Responses scanned:  ${stats.responses}`);
+  console.log(`Verdicts:`);
+  console.log(`  Allowed:          ${stats.allowed} (${pct(stats.allowed)}%)`);
+  console.log(`  Blocked:          ${stats.blocked} (${pct(stats.blocked)}%)`);
+  console.log(`  Observed:         ${stats.observed} (${pct(stats.observed)}%)`);
+  console.log(`  Errors/Bypassed:  ${stats.errors} (${pct(stats.errors)}%)`);
+
+  if (Object.keys(detections).length > 0) {
+    console.log(`Detection triggers:`);
+    for (const [service, count] of Object.entries(detections)) {
+      console.log(`  ${service}: ${count}`);
+    }
+  }
+
+  console.log(`Latency:`);
+  console.log(`  p50:              ${stats.latency.p50}ms`);
+  console.log(`  p95:              ${stats.latency.p95}ms`);
+  console.log(`  p99:              ${stats.latency.p99}ms`);
+}
+
+main();

package/scripts/install-hooks.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env tsx
+/**
+ * Install Prisma AIRS hooks into Cursor.
+ *
+ * Usage:
+ *   npx tsx scripts/install-hooks.ts             # project-level (.cursor/hooks.json)
+ *   npx tsx scripts/install-hooks.ts --global     # user-level (~/.cursor/hooks.json)
+ *
+ * Cursor reads hooks.json from multiple locations (all execute if present):
+ *   1. Project:    <workspace>/.cursor/hooks.json
+ *   2. User:       ~/.cursor/hooks.json
+ *   3. Enterprise: /Library/Application Support/Cursor/hooks.json  (macOS)
+ *                  /etc/cursor/hooks.json                          (Linux)
+ */
+import {
+  mkdirSync,
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import type { CursorHooksConfig } from "../src/types.js";
+
+const PROJECT_ROOT = resolve(import.meta.dirname, "..");
+const isGlobal = process.argv.includes("--global");
+
+// Determine target paths based on scope
+const CURSOR_DIR = isGlobal
+  ? join(homedir(), ".cursor")
+  : join(process.cwd(), ".cursor");
+const HOOKS_JSON_PATH = join(CURSOR_DIR, "hooks.json");
+const AIRS_CONFIG_DIR = join(CURSOR_DIR, "hooks");
+const AIRS_CONFIG_DEST = join(AIRS_CONFIG_DIR, "airs-config.json");
+
+function main() {
+  const scope = isGlobal ? "global (user-level)" : "project-level";
+  console.log(`Installing Prisma AIRS Cursor hooks [${scope}]...\n`);
+
+  // ---- Validate environment ----
+  const apiKey = process.env.AIRS_API_KEY;
+  const apiEndpoint = process.env.AIRS_API_ENDPOINT;
+
+  if (!apiKey) {
+    console.warn(
+      "  WARNING: AIRS_API_KEY is not set in your environment.\n" +
+        "  Hooks will fail-open until this variable is available.\n" +
+        "  Set it with:  export AIRS_API_KEY=<your-x-pan-token>\n",
+    );
+  }
+  if (!apiEndpoint) {
+    console.warn(
+      "  WARNING: AIRS_API_ENDPOINT is not set in your environment.\n" +
+        "  Set it with:  export AIRS_API_ENDPOINT=https://<region>.api.prismacloud.io\n",
+    );
+  }
+
+  // ---- Create directories ----
+  mkdirSync(AIRS_CONFIG_DIR, { recursive: true });
+
+  // ---- Write or merge hooks.json ----
+  const distDir = join(PROJECT_ROOT, "dist", "hooks");
+  const beforePromptCmd = `node "${join(distDir, "before-submit-prompt.js")}"`;
+  const afterResponseCmd = `node "${join(distDir, "after-agent-response.js")}"`;
+
+  // Verify dist exists
+  if (!existsSync(distDir)) {
+    console.error("  ERROR: dist/ not found. Run 'npm run build' first.\n");
+    process.exit(1);
+  }
+
+  let existingConfig: CursorHooksConfig | null = null;
+  if (existsSync(HOOKS_JSON_PATH)) {
+    try {
+      existingConfig = JSON.parse(readFileSync(HOOKS_JSON_PATH, "utf-8"));
+      console.log(`  Found existing ${HOOKS_JSON_PATH} — merging AIRS hooks.\n`);
+    } catch {
+      console.warn(`  WARNING: existing hooks.json is invalid JSON — overwriting.\n`);
+    }
+  }
+
+  const hooksConfig: CursorHooksConfig = existingConfig ?? {
+    version: 1,
+    hooks: {},
+  };
+
+  // Ensure our hooks are registered (idempotent — don't duplicate)
+  if (!hooksConfig.hooks.beforeSubmitPrompt) {
+    hooksConfig.hooks.beforeSubmitPrompt = [];
+  }
+  const hasPromptHook = hooksConfig.hooks.beforeSubmitPrompt.some(
+    (h) => h.command.includes("before-submit-prompt"),
+  );
+  if (!hasPromptHook) {
+    hooksConfig.hooks.beforeSubmitPrompt.push({
+      command: beforePromptCmd,
+      timeout: 5000,
+      failClosed: false,
+    });
+  }
+
+  if (!hooksConfig.hooks.afterAgentResponse) {
+    hooksConfig.hooks.afterAgentResponse = [];
+  }
+  const hasResponseHook = hooksConfig.hooks.afterAgentResponse.some(
+    (h) => h.command.includes("after-agent-response"),
+  );
+  if (!hasResponseHook) {
+    hooksConfig.hooks.afterAgentResponse.push({
+      command: afterResponseCmd,
+      timeout: 5000,
+      failClosed: false,
+    });
+  }
+
+  writeFileSync(HOOKS_JSON_PATH, JSON.stringify(hooksConfig, null, 2) + "\n", "utf-8");
+  console.log(`  Wrote ${HOOKS_JSON_PATH}`);
+
+  // ---- Copy AIRS config template ----
+  if (!existsSync(AIRS_CONFIG_DEST)) {
+    copyFileSync(join(PROJECT_ROOT, "airs-config.json"), AIRS_CONFIG_DEST);
+    console.log(`  Copied airs-config.json → ${AIRS_CONFIG_DEST}`);
+  } else {
+    console.log(`  Config already exists at ${AIRS_CONFIG_DEST} (preserved)`);
+  }
+
+  // ---- Summary ----
+  console.log("\n✅ Hooks installed successfully\n");
+  if (isGlobal) {
+    console.log("  Scope: GLOBAL — hooks apply to ALL Cursor workspaces.\n");
+    console.log(`  hooks.json:  ${HOOKS_JSON_PATH}`);
+    console.log(`  airs-config: ${AIRS_CONFIG_DEST}\n`);
+  } else {
+    console.log("  Scope: PROJECT — hooks apply only to this workspace.\n");
+    console.log("  Tip: use --global to install for all workspaces:\n");
+    console.log("    npm run install-hooks -- --global\n");
+  }
+  console.log("  Cursor will run these hooks automatically:");
+  console.log("    beforeSubmitPrompt  → scans prompts via Prisma AIRS");
+  console.log("    afterAgentResponse  → scans AI responses (incl. code extraction)\n");
+  console.log("  Environment variables (set in your shell profile):");
+  console.log("    AIRS_API_KEY            — x-pan-token for AIRS API (required)");
+  console.log("    AIRS_API_ENDPOINT       — regional base URL (optional, defaults to US)");
+  console.log("    AIRS_PROMPT_PROFILE     — prompt security profile name (optional)");
+  console.log("    AIRS_RESPONSE_PROFILE   — response security profile name (optional)\n");
+  console.log("  Next steps:");
+  console.log("    1. npm run validate-connection");
+  console.log("    2. npm run validate-detection");
+  console.log("    3. Restart Cursor to pick up the new hooks.json");
+}
+
+main();