codiedev 0.9.56 → 0.10.0-beta.2

package/dist/commands/security.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSecurityCommand = runSecurityCommand;
+const securityInstall_1 = require("../securityInstall");
+const securityPilot_1 = require("../securityPilot");
+const securityPolicy_1 = require("../securityPolicy");
+const securityInventory_1 = require("../securityInventory");
+const securityDeepScan_1 = require("../securityDeepScan");
+const utils_1 = require("../utils");
+const securityDoctor_1 = require("../securityDoctor");
+const securityFeature_1 = require("../securityFeature");
+const SECURITY_USAGE = "Usage: codiedev security <doctor|pilot|inventory|scan|sync|rollback> [--json] [--deep] [--connect-mcp] [--supply-chain] [--no-upload] [--yes]";
+function printPilot(json) {
+    const report = (0, securityPilot_1.runSyntheticSecurityPilot)();
+    if (json) {
+        console.log(JSON.stringify(report, null, 2));
+        return report.ok;
+    }
+    console.log("\nCodiedev security pilot — synthetic, side-effect-free validation\n");
+    for (const item of report.cases) {
+        console.log(`${item.passed ? "✓" : "✗"} ${item.surface}: ${item.name} (${item.actual})`);
+    }
+    console.log(`\n${report.ok ? "PASS" : "FAIL"}: ${report.cases.filter((item) => item.passed).length}/${report.cases.length} policy checks matched.`);
+    console.log("No commands were executed and no real credentials were used.\n");
+    return report.ok;
+}
+function printDoctor(json, companyId) {
+    const result = (0, securityDoctor_1.collectSecurityDoctorReport)(companyId);
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return result.ok;
+    }
+    console.log("\nCodiedev doctor — Agent Security details\n");
+    for (const check of (0, securityDoctor_1.securityDoctorChecks)(result)) {
+        const mark = check.status === "pass" ? "✓" : check.status === "warn" ? "!" : "✗";
+        console.log(`${mark} ${check.name}: ${check.detail}`);
+    }
+    console.log(`\n${result.ok ? "PASS" : "FAIL"}: ${result.ok ? "endpoint security is healthy" : "run `codiedev connect`, then repeat this check"}.\n`);
+    return result.ok;
+}
+async function runSecurityCommand(args) {
+    const subcommand = args.find((arg) => !arg.startsWith("-")) ?? "doctor";
+    const json = args.includes("--json");
+    if (args.includes("--help") || args.includes("-h") || subcommand === "help") {
+        console.log(SECURITY_USAGE);
+        return;
+    }
+    const connectedConfig = (0, utils_1.readConfig)();
+    const requiresEntitlement = !["pilot", "self-test"].includes(subcommand);
+    if (requiresEntitlement && (!connectedConfig || !(0, securityFeature_1.isAgentSecurityEnabled)(connectedConfig))) {
+        const detail = connectedConfig
+            ? `Agent Security is not enabled for ${connectedConfig.companyName}.`
+            : "Not connected. Run `codiedev connect` first.";
+        if (json)
+            console.log(JSON.stringify({ schemaVersion: 1, enabled: false, detail }, null, 2));
+        else
+            console.log(`\n${detail}\n`);
+        return;
+    }
+    if (subcommand === "inventory" || subcommand === "scan") {
+        const workspaceFlag = args.indexOf("--workspace");
+        const workspace = workspaceFlag >= 0 && args[workspaceFlag + 1]
+            ? args[workspaceFlag + 1]
+            : process.cwd();
+        const inventory = (0, securityInventory_1.buildSecurityInventory)({ workspace });
+        const deep = subcommand === "scan" && args.includes("--deep")
+            ? (0, securityDeepScan_1.runDeepSecurityScan)(inventory, {
+                workspace,
+                connectMcp: args.includes("--connect-mcp"),
+                supplyChain: args.includes("--supply-chain"),
+            })
+            : undefined;
+        const uploadableInventory = deep ? (0, securityDeepScan_1.mergeDeepScanFindings)(inventory, deep) : inventory;
+        let upload;
+        const config = (0, utils_1.readConfig)();
+        if (config && !args.includes("--no-upload")) {
+            try {
+                upload = await (0, securityInventory_1.uploadSecurityInventory)(uploadableInventory, config);
+            }
+            catch (error) {
+                if (!json)
+                    console.warn(`Inventory upload failed; local scan is still valid: ${error.message}`);
+            }
+        }
+        const output = { inventory: uploadableInventory, scanners: (0, securityInventory_1.scannerAvailability)(), ...(deep ? { deep } : {}), ...(upload ? { upload } : {}) };
+        if (json)
+            console.log(JSON.stringify(output, null, 2));
+        else {
+            const risky = inventory.components.filter((component) => component.findings.length > 0).length;
+            console.log(`\nCodiedev security inventory — ${inventory.components.length} components, ${risky} with local findings, ${inventory.drift.length} changed\n`);
+            const counts = new Map();
+            for (const component of inventory.components)
+                counts.set(component.kind, (counts.get(component.kind) ?? 0) + 1);
+            for (const [kind, count] of [...counts].sort())
+                console.log(`  ${kind}: ${count}`);
+            if (deep)
+                for (const run of deep.runs)
+                    console.log(`  ${run.scanner}: ${run.status} — ${run.detail}`);
+            if (upload)
+                console.log(`\nUploaded ${upload.accepted} component records to the security workspace.`);
+            console.log("\nUse --json for machine-readable hashes and findings. Use scan --deep for installed OSS scanners; --connect-mcp and --supply-chain are explicit because they start or download third-party code.\n");
+        }
+        return;
+    }
+    if (subcommand === "sync") {
+        const config = (0, utils_1.readConfig)();
+        if (!config) {
+            console.error("Not connected. Run `codiedev connect` first.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const policy = await (0, securityPolicy_1.syncEndpointSecurityPolicy)(config);
+            if (json)
+                console.log(JSON.stringify({ ok: true, policy }, null, 2));
+            else {
+                const verification = (0, securityPolicy_1.verifyEndpointSecurityPolicySignature)(policy);
+                console.log(`Security policy v${policy.policyVersion} synced (${policy.enforcementMode} mode; ${verification.detail}).`);
+            }
+        }
+        catch (error) {
+            console.error(`Security policy sync failed: ${error.message}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (subcommand === "rollback") {
+        if (!args.includes("--yes")) {
+            console.error("Rollback overwrites the installed agent hook configurations. Re-run with `codiedev security rollback --yes` after confirming the snapshot shown by `codiedev doctor`.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const result = (0, securityInstall_1.restoreSecurityInstallSnapshot)((0, securityInstall_1.readSecurityInstallManifest)());
+            if (json)
+                console.log(JSON.stringify({ schemaVersion: 1, ok: true, ...result }, null, 2));
+            else
+                console.log(`Restored ${result.restored} hook configuration(s) from snapshot ${result.snapshotId}.`);
+        }
+        catch (error) {
+            console.error(`Rollback failed: ${error.message}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const ok = subcommand === "pilot" || subcommand === "self-test"
+        ? printPilot(json)
+        : subcommand === "doctor" || subcommand === "status"
+            ? printDoctor(json, connectedConfig.companyId)
+            : false;
+    if (!["pilot", "self-test", "doctor", "status"].includes(subcommand)) {
+        console.error(SECURITY_USAGE);
+    }
+    if (!ok)
+        process.exitCode = 1;
+}

package/dist/connect.js

@@ -39,11 +39,16 @@ const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const crypto = __importStar(require("crypto"));
 const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const utils_1 = require("./utils");
 const connectFlow_1 = require("./connectFlow");
 const version_1 = require("./version");
 const upgradeNudge_1 = require("./upgradeNudge");
 const shared_1 = require("./commands/shared");
+const securityInstall_1 = require("./securityInstall");
+const securityPolicy_1 = require("./securityPolicy");
+const securityFeature_1 = require("./securityFeature");
 // cli.codiedev.com is a Convex custom domain on the prod deployment; the
 // underlying judicious-falcon-861.convex.site URL keeps serving, so configs
 // written by older CLI versions stay valid without a re-connect.
@@ -200,6 +205,7 @@ async function runConnect(args = []) {
     // Extract fields from response
     const companyId = responseData.companyId;
     const companyName = responseData.companyName;
+    const agentSecurityEnabled = responseData.agentSecurityEnabled === true;
     const repos = responseData.repos ?? [];
     if (!companyId || !companyName) {
         console.error("\nError: Invalid response from server. Token may be invalid.");
@@ -212,6 +218,7 @@ async function runConnect(args = []) {
         repos,
         lastSynced: new Date().toISOString(),
         backendUrl: BACKEND_URL,
+        agentSecurityEnabled,
         deviceId: saved?.deviceId || crypto.randomUUID(),
         deviceName: saved?.deviceName || os.hostname(),
         captureIgnoredPaths: saved?.captureIgnoredPaths ?? [],
@@ -280,6 +287,17 @@ async function runConnect(args = []) {
     // /api/cli/markInstalled so the portal's "Connected" state reflects
     // what's actually wired up on this machine, not just "token validated."
     const installedTargets = [];
+    const home = os.homedir();
+    const securityConfigPaths = [
+        path.join(home, ".claude", "settings.json"),
+        path.join(home, ".codex", "hooks.json"),
+        path.join(home, ".cursor", "hooks.json"),
+        path.join(home, ".config", "opencode", "plugins", "codiedev.js"),
+        path.join(home, ".codex", "config.toml"),
+    ];
+    // Snapshot before any hook update. Rollback is intentionally not automatic:
+    // an administrator can inspect these 0600 copies before restoring them.
+    const securitySnapshot = (0, securityInstall_1.createSecurityInstallSnapshot)(securityConfigPaths);
     // Wrap each per-target write so we emit one install_target row each. The
     // existing user-visible behavior (console.warn on failure, continue) is
     // unchanged — telemetry just observes the outcome.
@@ -302,21 +320,52 @@ async function runConnect(args = []) {
         }
     };
     if (hasClaude) {
-        runInstall("claude-code-hook", utils_1.installHook, "Claude Code SessionEnd (capture) + UserPromptSubmit (skill discovery) + Stop (auto-backup) hooks (~/.claude/settings.json)", "claudeCode-hook");
+        runInstall("claude-code-hook", () => (0, utils_1.installHook)(agentSecurityEnabled), "Claude Code SessionEnd (capture) + UserPromptSubmit (skill discovery) + Stop (auto-backup) hooks (~/.claude/settings.json)", "claudeCode-hook");
         runInstall("claude-code-instructions", utils_1.installClaudeCodeInstructions, "Claude Code agent instructions (~/.claude/CLAUDE.md)", "claudeCode-instructions");
     }
     if (hasCodex) {
-        runInstall("codex-hook", utils_1.installCodexHook, "Codex Stop (capture + auto-backup) hooks (~/.codex/hooks.json)", "codex-hook");
+        runInstall("codex-hook", () => (0, utils_1.installCodexHook)(agentSecurityEnabled), "Codex Stop (capture + auto-backup) hooks (~/.codex/hooks.json)", "codex-hook");
         runInstall("codex-instructions", utils_1.installCodexInstructions, "Codex agent instructions (~/.codex/AGENTS.md)", "codex-instructions");
     }
     if (hasCursor) {
-        runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionStart + stop backup + sessionEnd capture hooks (~/.cursor/hooks.json)", "cursor-hook");
+        runInstall("cursor-hook", () => (0, utils_1.installCursorHook)(agentSecurityEnabled), "Cursor sessionStart + prompt security + stop backup + sessionEnd capture hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
     // Always stage the adapter. It is dormant until OpenCode starts, which lets
     // a user connect Claude Code today and install the Codie harness tomorrow
     // without needing a second setup ritual.
-    runInstall("opencode-capture-adapter", utils_1.installOpenCodeCapturePlugin, "OpenCode session capture adapter (~/.config/opencode/plugins/codiedev.js)", "opencode-capture");
+    runInstall("opencode-capture-adapter", () => (0, utils_1.installOpenCodeCapturePlugin)(agentSecurityEnabled), "OpenCode session capture adapter (~/.config/opencode/plugins/codiedev.js)", "opencode-capture");
+    // Record the exact installed hook bytes and the pre-update rollback files.
+    // This supplies health/integrity checks without requiring a package publish
+    // or trusting whichever `node` happens to be first on PATH later.
+    try {
+        const hookScriptPath = path.join(__dirname, "hook.js");
+        if (agentSecurityEnabled && fs.existsSync(hookScriptPath)) {
+            const targets = [];
+            if (installedTargets.includes("claudeCode-hook"))
+                targets.push({ surface: "claude-code", configPath: securityConfigPaths[0] });
+            if (installedTargets.includes("codex-hook"))
+                targets.push({ surface: "codex", configPath: securityConfigPaths[1] });
+            if (installedTargets.includes("cursor-hook"))
+                targets.push({ surface: "cursor", configPath: securityConfigPaths[2] });
+            if (installedTargets.includes("opencode-capture"))
+                targets.push({ surface: "codie-harness", configPath: securityConfigPaths[3] });
+            (0, securityInstall_1.writeSecurityInstallManifest)({ hookScriptPath, snapshot: securitySnapshot, targets });
+        }
+    }
+    catch (err) {
+        console.warn(`Warning: Security hooks installed, but integrity manifest could not be written — ${err.message}`);
+    }
+    // Prime the local cache after installation. Hooks read this file only, so
+    // an endpoint decision never depends on live network latency.
+    if (agentSecurityEnabled) {
+        try {
+            await (0, securityPolicy_1.syncEndpointSecurityPolicy)(config);
+        }
+        catch (err) {
+            console.warn(`Warning: Agent-security policy will use safe defaults until sync succeeds — ${err.message}`);
+        }
+    }
     // Tell the backend which targets we wired up so the portal's onboarding
     // card flips to "Connected" only when something actually installed —
     // not on bare token validation. Best-effort: a network failure here
@@ -355,5 +404,8 @@ async function runConnect(args = []) {
     }
     console.log();
     console.log("Run `codiedev doctor` to verify everything's wired up.");
+    if ((0, securityFeature_1.isAgentSecurityEnabled)(config)) {
+        console.log("Run `codiedev security pilot` to validate blocking safely.");
+    }
     console.log();
 }

package/dist/cursorHooks.d.ts

@@ -1,9 +1,23 @@
-/** Normalize Cursor's native hook payload into the shared capture shape. */
+/** Cursor's native hook payload is close to Claude Code's, but its stable
+ * conversation identifier and several tool fields use different names. Keep
+ * the translation at the process boundary so the shared capture/security
+ * pipeline never has to guess which surface produced an event. */
 export declare function normalizeCursorHookInput<T extends Record<string, unknown>>(input: T): T & Record<string, unknown>;
-/** Add Claude-compatible message discriminators while preserving Cursor JSONL. */
+/** Cursor stores JSONL message roles in `role`; the shared capture pipeline
+ * uses Claude's top-level `type` discriminator. Preserve all original fields
+ * and add only that discriminator so the existing parsers see real messages. */
 export declare function normalizeCursorTranscript(content: string): string;
 /** Cursor may change its private JSONL record shape independently of the hook
  * contract. Only a byte-empty snapshot is safe to discard; a non-empty file
  * that the current normalizer cannot parse must still be uploaded for backend
  * recovery and diagnosis. */
 export declare function isCursorTranscriptEmpty(content: string): boolean;
+export declare function cursorPreToolBlockResponse(reason: string): {
+    permission: "deny";
+    user_message: string;
+    agent_message: string;
+};
+export declare function cursorPromptBlockResponse(reason: string): {
+    continue: false;
+    user_message: string;
+};

package/dist/cursorHooks.js

@@ -3,7 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeCursorHookInput = normalizeCursorHookInput;
 exports.normalizeCursorTranscript = normalizeCursorTranscript;
 exports.isCursorTranscriptEmpty = isCursorTranscriptEmpty;
-/** Normalize Cursor's native hook payload into the shared capture shape. */
+exports.cursorPreToolBlockResponse = cursorPreToolBlockResponse;
+exports.cursorPromptBlockResponse = cursorPromptBlockResponse;
+/** Cursor's native hook payload is close to Claude Code's, but its stable
+ * conversation identifier and several tool fields use different names. Keep
+ * the translation at the process boundary so the shared capture/security
+ * pipeline never has to guess which surface produced an event. */
 function normalizeCursorHookInput(input) {
     const sessionId = firstString(input.session_id, input.sessionId, input.conversation_id);
     const roots = Array.isArray(input.workspace_roots)
@@ -24,22 +29,29 @@ function normalizeCursorHookInput(input) {
         ...(duration !== undefined ? { duration_ms: duration } : {}),
     };
 }
-/** Add Claude-compatible message discriminators while preserving Cursor JSONL. */
+/** Cursor stores JSONL message roles in `role`; the shared capture pipeline
+ * uses Claude's top-level `type` discriminator. Preserve all original fields
+ * and add only that discriminator so the existing parsers see real messages. */
 function normalizeCursorTranscript(content) {
-    return content.split("\n").map((line) => {
+    return content
+        .split("\n")
+        .map((line) => {
         if (!line.trim())
             return line;
         try {
             const entry = JSON.parse(line);
-            if ((entry.role === "user" || entry.role === "assistant") && entry.type === undefined) {
+            if ((entry.role === "user" || entry.role === "assistant") &&
+                entry.type === undefined) {
                 return JSON.stringify({ ...entry, type: entry.role });
             }
         }
         catch {
-            // Tolerant downstream parsers skip malformed/non-JSON lines.
+            // Preserve malformed/non-JSON lines; tolerant downstream parsers skip
+            // anything they cannot consume.
         }
         return line;
-    }).join("\n");
+    })
+        .join("\n");
 }
 /** Cursor may change its private JSONL record shape independently of the hook
  * contract. Only a byte-empty snapshot is safe to discard; a non-empty file
@@ -54,3 +66,16 @@ function firstString(...values) {
 function firstNumber(...values) {
     return values.find((value) => typeof value === "number" && Number.isFinite(value));
 }
+function cursorPreToolBlockResponse(reason) {
+    return {
+        permission: "deny",
+        user_message: reason,
+        agent_message: reason,
+    };
+}
+function cursorPromptBlockResponse(reason) {
+    return {
+        continue: false,
+        user_message: reason,
+    };
+}