fullcourtdefense-cli 1.0.2 → 1.1.1

package/dist/commands/init.js

@@ -68,20 +68,20 @@ async function initCommand() {
     const categories = categoriesRaw === 'all'
         ? '[jailbreak, prompt_injection, data_extraction, role_manipulation, encoding_attack, social_engineering]'
         : `[${categoriesRaw}]`;
-    const content = `# FullCourtDefense CLI Configuration
-# Docs: https://fullcourtdefense.ai/docs/cli
-
-apiKey: \${BOTGUARD_API_KEY}
-apiUrl: https://api.fullcourtdefense.ai
-shieldId: ${shieldId}
-${shieldKey ? `shieldKey: ${shieldKey}\n` : ''}
-
-scan:
-  endpoint: ${endpoint}
-  description: "${description}"
-  categories: ${categories}
-  failThreshold: ${threshold}
-  format: table
+    const content = `# FullCourtDefense CLI Configuration
+# Docs: https://fullcourtdefense.ai/docs/cli
+
+apiKey: \${FULLCOURTDEFENSE_API_KEY}
+apiUrl: https://api.fullcourtdefense.ai
+shieldId: ${shieldId}
+${shieldKey ? `shieldKey: ${shieldKey}\n` : ''}
+
+scan:
+  endpoint: ${endpoint}
+  description: "${description}"
+  categories: ${categories}
+  failThreshold: ${threshold}
+  format: table
 `;
     fs.writeFileSync(target, content, 'utf-8');
     console.log('');

package/dist/commands/installCursorHook.d.ts

@@ -0,0 +1,12 @@
+import { BotGuardConfig } from '../config';
+export interface InstallHookArgs {
+    project?: string;
+    shieldId?: string;
+    shieldKey?: string;
+    apiUrl?: string;
+    shadow?: string;
+    failClosed?: string;
+    events?: string;
+}
+export declare function installCursorHookCommand(args: InstallHookArgs, config: BotGuardConfig): Promise<void>;
+export declare function uninstallCursorHookCommand(args: InstallHookArgs): Promise<void>;

package/dist/commands/installCursorHook.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCursorHookCommand = installCursorHookCommand;
+exports.uninstallCursorHookCommand = uninstallCursorHookCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const COLOR = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    red: '\x1b[31m', yellow: '\x1b[33m', green: '\x1b[32m', cyan: '\x1b[36m', gray: '\x1b[90m',
+};
+// Stable marker embedded in every command we write, so uninstall/re-install can
+// find our entries regardless of the install path (npm global vs local dev).
+const MANAGED_MARKER = '--fcd-managed true';
+const MANAGED_TAG = 'fullcourtdefense';
+const EVENT_MAP = {
+    prompt: { hookKey: 'beforeSubmitPrompt', flag: 'prompt', failClosedDefault: false },
+    shell: { hookKey: 'beforeShellExecution', flag: 'shell', failClosedDefault: true },
+    mcp: { hookKey: 'beforeMCPExecution', flag: 'mcp', failClosedDefault: true },
+    file: { hookKey: 'afterFileEdit', flag: 'file', failClosedDefault: false },
+    read: { hookKey: 'beforeReadFile', flag: 'read', failClosedDefault: false },
+};
+/** Build the absolute, shell-agnostic command that invokes this CLI's `hook`. */
+function buildHookCommand(flag, opts) {
+    const nodeExe = process.execPath; // real node binary (handles Windows/Linux/mac)
+    const scriptPath = process.argv[1] || path.join(__dirname, '..', 'index.js');
+    const q = (s) => (/\s/.test(s) ? `"${s}"` : s);
+    let cmd = `${q(nodeExe)} ${q(scriptPath)} hook --event ${flag}`;
+    if (opts.shadow)
+        cmd += ' --shadow true';
+    if (opts.failClosed)
+        cmd += ' --fail-closed true';
+    cmd += ` ${MANAGED_MARKER}`;
+    return cmd;
+}
+function hooksJsonPath(projectScope) {
+    return projectScope
+        ? path.join(process.cwd(), '.cursor', 'hooks.json')
+        : path.join(os.homedir(), '.cursor', 'hooks.json');
+}
+function readHooksJson(file) {
+    if (!fs.existsSync(file))
+        return { version: 1, hooks: {} };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!parsed || typeof parsed !== 'object')
+            return { version: 1, hooks: {} };
+        parsed.version = parsed.version || 1;
+        parsed.hooks = parsed.hooks && typeof parsed.hooks === 'object' ? parsed.hooks : {};
+        return parsed;
+    }
+    catch {
+        return { version: 1, hooks: {} };
+    }
+}
+function isManaged(entry) {
+    return typeof entry?.command === 'string'
+        && (entry.command.includes(MANAGED_MARKER) || entry.command.includes(MANAGED_TAG));
+}
+/** Save the home-level Shield credentials so the hook can find them machine-wide. */
+function writeHomeShield(input) {
+    if (!input.shieldId && !input.shieldKey && !input.apiUrl)
+        return undefined;
+    const target = path.join(os.homedir(), '.fullcourtdefense.yml');
+    const existing = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : '# FullCourtDefense CLI Configuration\n';
+    const lines = existing.split(/\r?\n/);
+    const setKey = (key, value) => {
+        if (!value)
+            return;
+        const idx = lines.findIndex((l) => new RegExp(`^\\s*${key}\\s*:`).test(l));
+        const next = `${key}: ${value}`;
+        if (idx >= 0)
+            lines[idx] = next;
+        else
+            lines.push(next);
+    };
+    setKey('shieldId', input.shieldId);
+    setKey('shieldKey', input.shieldKey);
+    setKey('apiUrl', input.apiUrl);
+    fs.writeFileSync(target, lines.filter((l, i, a) => !(l === '' && a[i - 1] === '')).join('\n').trim() + '\n', 'utf8');
+    return target;
+}
+async function installCursorHookCommand(args, config) {
+    const projectScope = args.project === 'true';
+    const shadow = args.shadow === 'true';
+    const file = hooksJsonPath(projectScope);
+    const requested = (args.events || 'prompt,shell,mcp')
+        .split(',').map((e) => e.trim().toLowerCase()).filter(Boolean);
+    const events = requested.filter((e) => EVENT_MAP[e]);
+    if (events.length === 0) {
+        console.error(`${COLOR.red}No valid events. Choose from: ${Object.keys(EVENT_MAP).join(', ')}${COLOR.reset}`);
+        process.exit(1);
+    }
+    // Persist creds machine-wide (home) so the runtime hook resolves them.
+    const shieldId = args.shieldId || config.shieldId;
+    const shieldKey = args.shieldKey || config.shieldKey;
+    const apiUrl = args.apiUrl || config.apiUrl;
+    const credFile = writeHomeShield({ shieldId, shieldKey, apiUrl });
+    const json = readHooksJson(file);
+    for (const e of events) {
+        const { hookKey, flag, failClosedDefault } = EVENT_MAP[e];
+        const failClosed = args.failClosed !== undefined ? args.failClosed === 'true' : failClosedDefault;
+        const entry = {
+            command: buildHookCommand(flag, { shadow, failClosed }),
+            timeout: 10,
+        };
+        if (failClosed)
+            entry.failClosed = true;
+        const list = Array.isArray(json.hooks[hookKey]) ? json.hooks[hookKey] : [];
+        // Replace any prior FullCourtDefense-managed entry; preserve the user's other hooks.
+        const preserved = list.filter((x) => !isManaged(x));
+        json.hooks[hookKey] = [...preserved, entry];
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(json, null, 2) + '\n', 'utf8');
+    console.log('');
+    console.log(`${COLOR.green}${COLOR.bold}FullCourtDefense Cursor hook installed.${COLOR.reset}`);
+    console.log(`${COLOR.gray}Scope:${COLOR.reset} ${projectScope ? 'project (.cursor/hooks.json)' : 'machine-wide (~/.cursor/hooks.json)'}`);
+    console.log(`${COLOR.gray}File:${COLOR.reset}  ${file}`);
+    console.log(`${COLOR.gray}Events:${COLOR.reset} ${events.map((e) => EVENT_MAP[e].hookKey).join(', ')}`);
+    if (shadow)
+        console.log(`${COLOR.yellow}Mode: SHADOW (monitor only — nothing is blocked).${COLOR.reset}`);
+    if (credFile)
+        console.log(`${COLOR.gray}Creds:${COLOR.reset} ${credFile}`);
+    if (!shieldId) {
+        console.log('');
+        console.log(`${COLOR.yellow}No Shield ID set.${COLOR.reset} Run ${COLOR.bold}fullcourtdefense configure${COLOR.reset} or pass ${COLOR.bold}--shield-id${COLOR.reset}, then re-run install.`);
+    }
+    console.log('');
+    console.log(`${COLOR.gray}Restart Cursor (or it will hot-reload hooks.json). Verify in Cursor → Settings → Hooks.${COLOR.reset}`);
+    console.log(`${COLOR.gray}Remove with:${COLOR.reset} fullcourtdefense uninstall-cursor-hook${projectScope ? ' --project true' : ''}`);
+}
+async function uninstallCursorHookCommand(args) {
+    const projectScope = args.project === 'true';
+    const file = hooksJsonPath(projectScope);
+    if (!fs.existsSync(file)) {
+        console.log(`${COLOR.yellow}No hooks.json found at ${file}. Nothing to remove.${COLOR.reset}`);
+        return;
+    }
+    const json = readHooksJson(file);
+    let removed = 0;
+    for (const key of Object.keys(json.hooks)) {
+        const list = Array.isArray(json.hooks[key]) ? json.hooks[key] : [];
+        const kept = list.filter((x) => !isManaged(x));
+        removed += list.length - kept.length;
+        if (kept.length)
+            json.hooks[key] = kept;
+        else
+            delete json.hooks[key];
+    }
+    fs.writeFileSync(file, JSON.stringify(json, null, 2) + '\n', 'utf8');
+    console.log(`${COLOR.green}Removed ${removed} FullCourtDefense hook entr${removed === 1 ? 'y' : 'ies'} from ${file}.${COLOR.reset}`);
+}

package/dist/commands/local-scan.d.ts

@@ -37,5 +37,8 @@ export interface LocalScanArgs {
     configShieldKey?: string;
     configApiUrl?: string;
     apiUrl?: string;
+    open?: string;
+    noOpen?: string;
+    openUi?: string;
 }
 export declare function localScanCommand(args: LocalScanArgs): Promise<void>;