@oculisecurity/cli 0.1.0

package/dist/services/audit.d.ts

@@ -0,0 +1,92 @@
+import { AuditRecord } from '../types';
+import { AppConfig } from '../config';
+export declare class AuditService {
+    private readonly db;
+    readonly storeFullArgs: boolean;
+    constructor(config: AppConfig);
+    private initialize;
+    /** Read the persisted byte offset for an absolute jsonl path. Zero when missing. */
+    private getReplayOffset;
+    private setReplayOffset;
+    /** SHA-256 hex prefix of JSON-serialised data */
+    hash(data: unknown): string;
+    log(record: Omit<AuditRecord, 'id'>): void;
+    /** Read recent audit records (descending by timestamp) */
+    query(limit?: number, offset?: number): AuditRecord[];
+    /** Count total rows */
+    count(): number;
+    /** Summary stats for the last N hours */
+    summary(hours?: number): {
+        totalCalls: number;
+        deniedCalls: number;
+        avgLatencyMs: number;
+        rateLimitViolations: number;
+    };
+    /** Top N tools by total call count */
+    topTools(limit?: number): Array<{
+        tool: string;
+        count: number;
+    }>;
+    /** Top N denied tools */
+    topDeniedTools(limit?: number): Array<{
+        tool: string;
+        count: number;
+    }>;
+    /** Top N actors by activity */
+    topActors(limit?: number): Array<{
+        actor: string;
+        count: number;
+    }>;
+    /** Allowed vs denied breakdown */
+    decisionBreakdown(): {
+        allowed: number;
+        denied: number;
+    };
+    /** Time-series: calls grouped into fixed-width buckets */
+    timeSeries(hours?: number, bucketMinutes?: number): Array<{
+        bucket: string;
+        count: number;
+    }>;
+    /** Search audit records with optional filters */
+    search(opts: {
+        q?: string;
+        decision?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+        offset?: number;
+    }): {
+        total: number;
+        results: AuditRecord[];
+    };
+    private static readonly ALLOWED_GROUP_BY_FIELDS;
+    /** Group-by aggregation with optional WHERE filters */
+    aggregate(opts: {
+        groupBy: string[];
+        q?: string;
+        decision?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): {
+        groupBy: string[];
+        results: Array<Record<string, string | number>>;
+    };
+    /**
+     * Backfill audit_logs from `~/.oculi/telemetry.jsonl` (or whichever path is
+     * passed). Resumes from the persisted byte offset, so re-running serve does
+     * not double-count. Returns counts for observability.
+     *
+     * The CLI client always appends to telemetry.jsonl; the gateway only writes
+     * to sqlite. Without this replay, events generated while `oculi serve` was
+     * NOT running are invisible to the dashboard. See plan file for the full
+     * divergence analysis.
+     */
+    replayFromTelemetry(jsonlPath: string): {
+        inserted: number;
+        skipped: number;
+        newOffset: number;
+        rotated: boolean;
+    };
+    close(): void;
+}

package/dist/services/audit.js

@@ -0,0 +1,388 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditService = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sqlite_loader_1 = require("./sqlite-loader");
+const telemetry_log_1 = require("./telemetry-log");
+class AuditService {
+    db;
+    storeFullArgs;
+    constructor(config) {
+        this.storeFullArgs = config.storeFullArgs;
+        // Ensure data directory exists
+        const dir = path_1.default.dirname(config.dbPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        const Ctor = (0, sqlite_loader_1.loadSqlite)();
+        this.db = new Ctor(config.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.initialize();
+    }
+    initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS audit_logs (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        requestId     TEXT NOT NULL,
+        timestamp     TEXT NOT NULL,
+        actor         TEXT NOT NULL,
+        orgId         TEXT NOT NULL,
+        upstreamId    TEXT NOT NULL,
+        tool          TEXT NOT NULL,
+        argsHash      TEXT NOT NULL,
+        argsJson      TEXT,
+        decision      TEXT NOT NULL CHECK(decision IN ('allow', 'deny')),
+        reason        TEXT NOT NULL,
+        latencyMs     INTEGER NOT NULL,
+        outcome       TEXT NOT NULL CHECK(outcome IN ('success', 'error', 'denied')),
+        responseHash  TEXT,
+        ip            TEXT NOT NULL,
+        sessionId     TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_audit_actor     ON audit_logs(actor);
+      CREATE INDEX IF NOT EXISTS idx_audit_tool      ON audit_logs(tool);
+      CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON audit_logs(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_audit_decision  ON audit_logs(decision);
+      CREATE INDEX IF NOT EXISTS idx_audit_requestId ON audit_logs(requestId);
+
+      CREATE TABLE IF NOT EXISTS replay_state (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+        // Migration: add responseJson column to existing databases (SQLite ignores duplicate ADD COLUMN errors)
+        try {
+            this.db.exec('ALTER TABLE audit_logs ADD COLUMN responseJson TEXT');
+        }
+        catch {
+            // Column already exists — no-op
+        }
+    }
+    /** Read the persisted byte offset for an absolute jsonl path. Zero when missing. */
+    getReplayOffset(jsonlPath) {
+        const key = `replay:${jsonlPath}`;
+        const row = this.db
+            .prepare('SELECT value FROM replay_state WHERE key = ?')
+            .get(key);
+        if (!row)
+            return 0;
+        const n = parseInt(row.value, 10);
+        return Number.isFinite(n) && n >= 0 ? n : 0;
+    }
+    setReplayOffset(jsonlPath, offset) {
+        const key = `replay:${jsonlPath}`;
+        this.db
+            .prepare('INSERT INTO replay_state (key, value) VALUES (?, ?) ' +
+            'ON CONFLICT(key) DO UPDATE SET value = excluded.value')
+            .run(key, String(offset));
+    }
+    /** SHA-256 hex prefix of JSON-serialised data */
+    hash(data) {
+        return crypto_1.default
+            .createHash('sha256')
+            .update(JSON.stringify(data))
+            .digest('hex')
+            .slice(0, 16);
+    }
+    log(record) {
+        const stmt = this.db.prepare(`
+      INSERT INTO audit_logs (
+        requestId, timestamp, actor, orgId, upstreamId, tool,
+        argsHash, argsJson, decision, reason, latencyMs,
+        outcome, responseHash, responseJson, ip, sessionId
+      ) VALUES (
+        @requestId, @timestamp, @actor, @orgId, @upstreamId, @tool,
+        @argsHash, @argsJson, @decision, @reason, @latencyMs,
+        @outcome, @responseHash, @responseJson, @ip, @sessionId
+      )
+    `);
+        stmt.run({
+            ...record,
+            argsJson: record.argsJson ?? null,
+            responseHash: record.responseHash ?? null,
+            responseJson: record.responseJson ?? null,
+        });
+    }
+    /** Read recent audit records (descending by timestamp) */
+    query(limit = 100, offset = 0) {
+        return this.db
+            .prepare('SELECT * FROM audit_logs ORDER BY timestamp DESC LIMIT ? OFFSET ?')
+            .all(limit, offset);
+    }
+    /** Count total rows */
+    count() {
+        const row = this.db
+            .prepare('SELECT COUNT(*) as n FROM audit_logs')
+            .get();
+        return row.n;
+    }
+    /** Summary stats for the last N hours */
+    summary(hours = 24) {
+        const since = new Date(Date.now() - hours * 3600_000).toISOString();
+        const row = this.db
+            .prepare(`SELECT
+          COUNT(*)                                            AS totalCalls,
+          SUM(CASE WHEN decision = 'deny' THEN 1 ELSE 0 END) AS deniedCalls,
+          COALESCE(AVG(latencyMs), 0)                         AS avgLatencyMs,
+          SUM(CASE WHEN reason = 'rate limit exceeded' THEN 1 ELSE 0 END) AS rateLimitViolations
+        FROM audit_logs
+        WHERE timestamp >= ?`)
+            .get(since);
+        return {
+            totalCalls: row.totalCalls,
+            deniedCalls: row.deniedCalls,
+            avgLatencyMs: Math.round(row.avgLatencyMs),
+            rateLimitViolations: row.rateLimitViolations,
+        };
+    }
+    /** Top N tools by total call count */
+    topTools(limit = 5) {
+        return this.db
+            .prepare(`SELECT tool, COUNT(*) AS count
+        FROM audit_logs
+        GROUP BY tool
+        ORDER BY count DESC
+        LIMIT ?`)
+            .all(limit);
+    }
+    /** Top N denied tools */
+    topDeniedTools(limit = 5) {
+        return this.db
+            .prepare(`SELECT tool, COUNT(*) AS count
+        FROM audit_logs
+        WHERE decision = 'deny'
+        GROUP BY tool
+        ORDER BY count DESC
+        LIMIT ?`)
+            .all(limit);
+    }
+    /** Top N actors by activity */
+    topActors(limit = 5) {
+        return this.db
+            .prepare(`SELECT actor, COUNT(*) AS count
+        FROM audit_logs
+        GROUP BY actor
+        ORDER BY count DESC
+        LIMIT ?`)
+            .all(limit);
+    }
+    /** Allowed vs denied breakdown */
+    decisionBreakdown() {
+        const row = this.db
+            .prepare(`SELECT
+          SUM(CASE WHEN decision = 'allow' THEN 1 ELSE 0 END) AS allowed,
+          SUM(CASE WHEN decision = 'deny'  THEN 1 ELSE 0 END) AS denied
+        FROM audit_logs`)
+            .get();
+        return { allowed: row.allowed ?? 0, denied: row.denied ?? 0 };
+    }
+    /** Time-series: calls grouped into fixed-width buckets */
+    timeSeries(hours = 1, bucketMinutes = 5) {
+        const since = new Date(Date.now() - hours * 3600_000).toISOString();
+        const bucketSeconds = bucketMinutes * 60;
+        return this.db
+            .prepare(`SELECT
+          strftime('%Y-%m-%dT%H:%M:00Z',
+            (CAST(strftime('%s', timestamp) AS INTEGER) / ${bucketSeconds}) * ${bucketSeconds},
+            'unixepoch'
+          ) AS bucket,
+          COUNT(*) AS count
+        FROM audit_logs
+        WHERE timestamp >= ?
+        GROUP BY bucket
+        ORDER BY bucket ASC`)
+            .all(since);
+    }
+    /** Search audit records with optional filters */
+    search(opts) {
+        const limit = Math.min(opts.limit ?? 100, 500);
+        const offset = opts.offset ?? 0;
+        const q = opts.q?.trim() || null;
+        const decision = opts.decision === 'allow' || opts.decision === 'deny' ? opts.decision : null;
+        const conditions = [];
+        const params = [];
+        if (q) {
+            conditions.push('(actor LIKE ? OR tool LIKE ? OR upstreamId LIKE ?)');
+            const like = '%' + q + '%';
+            params.push(like, like, like);
+        }
+        if (decision) {
+            conditions.push('decision = ?');
+            params.push(decision);
+        }
+        if (opts.from) {
+            conditions.push('timestamp >= ?');
+            params.push(opts.from);
+        }
+        if (opts.to) {
+            conditions.push('timestamp <= ?');
+            params.push(opts.to);
+        }
+        const where = conditions.length ? 'WHERE ' + conditions.join(' AND ') : '';
+        const total = this.db
+            .prepare('SELECT COUNT(*) AS n FROM audit_logs ' + where)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .get(...params).n;
+        const records = this.db
+            .prepare('SELECT * FROM audit_logs ' + where + ' ORDER BY timestamp DESC LIMIT ? OFFSET ?')
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .all(...params, limit, offset);
+        return { total, results: records };
+    }
+    static ALLOWED_GROUP_BY_FIELDS = {
+        actor: 'actor',
+        tool: 'tool',
+        upstream: 'upstreamId',
+        upstreamId: 'upstreamId',
+        decision: 'decision',
+        outcome: 'outcome',
+        orgId: 'orgId',
+    };
+    /** Group-by aggregation with optional WHERE filters */
+    aggregate(opts) {
+        const limit = Math.min(opts.limit ?? 100, 500);
+        const q = opts.q?.trim() || null;
+        const decision = opts.decision === 'allow' || opts.decision === 'deny' ? opts.decision : null;
+        // Map user-provided field names to SQL column names (injection prevention)
+        const allowlist = AuditService.ALLOWED_GROUP_BY_FIELDS;
+        const resolvedCols = opts.groupBy
+            .map((f) => allowlist[f] ?? null)
+            .filter((c) => c !== null);
+        if (resolvedCols.length === 0) {
+            return { groupBy: opts.groupBy, results: [] };
+        }
+        const conditions = [];
+        const params = [];
+        if (q) {
+            conditions.push('(actor LIKE ? OR tool LIKE ? OR upstreamId LIKE ?)');
+            const like = '%' + q + '%';
+            params.push(like, like, like);
+        }
+        if (decision) {
+            conditions.push('decision = ?');
+            params.push(decision);
+        }
+        if (opts.from) {
+            conditions.push('timestamp >= ?');
+            params.push(opts.from);
+        }
+        if (opts.to) {
+            conditions.push('timestamp <= ?');
+            params.push(opts.to);
+        }
+        const where = conditions.length ? 'WHERE ' + conditions.join(' AND ') : '';
+        const colList = resolvedCols.join(', ');
+        const sql = `SELECT ${colList}, COUNT(*) AS count FROM audit_logs ${where} GROUP BY ${colList} ORDER BY count DESC LIMIT ?`;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const rows = this.db.prepare(sql).all(...params, limit);
+        return { groupBy: opts.groupBy, results: rows };
+    }
+    /**
+     * Backfill audit_logs from `~/.oculi/telemetry.jsonl` (or whichever path is
+     * passed). Resumes from the persisted byte offset, so re-running serve does
+     * not double-count. Returns counts for observability.
+     *
+     * The CLI client always appends to telemetry.jsonl; the gateway only writes
+     * to sqlite. Without this replay, events generated while `oculi serve` was
+     * NOT running are invisible to the dashboard. See plan file for the full
+     * divergence analysis.
+     */
+    replayFromTelemetry(jsonlPath) {
+        const startOffset = this.getReplayOffset(jsonlPath);
+        const { entries, newOffset, skipped, rotated } = (0, telemetry_log_1.readTelemetryLinesFromOffset)(jsonlPath, startOffset);
+        if (entries.length === 0) {
+            // Persist newOffset anyway so a rotation reset (offset went 1000 → 0
+            // because the new file is smaller) is recorded.
+            if (newOffset !== startOffset)
+                this.setReplayOffset(jsonlPath, newOffset);
+            return { inserted: 0, skipped, newOffset, rotated };
+        }
+        let inserted = 0;
+        let perRowFailures = 0;
+        const insert = this.db.transaction((batch) => {
+            for (const entry of batch) {
+                try {
+                    const record = telemetryEntryToAuditRecord(entry, this.hash.bind(this));
+                    this.log(record);
+                    inserted++;
+                }
+                catch {
+                    // Per-row failure (e.g., a field combination that violates a CHECK
+                    // constraint). Skip this row but keep the rest of the batch.
+                    perRowFailures++;
+                }
+            }
+            this.setReplayOffset(jsonlPath, newOffset);
+        });
+        insert(entries);
+        return {
+            inserted,
+            skipped: skipped + perRowFailures,
+            newOffset,
+            rotated,
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.AuditService = AuditService;
+/**
+ * Map a telemetry jsonl entry to an audit_logs row.
+ *
+ * Key divergences from the live `POST /v1/hooks` write path ([routes/hooks.ts]):
+ *   - `requestId` is freshly generated (jsonl has no equivalent).
+ *   - `argsJson` is always null (matches the gateway's `storeFullArgs: false`
+ *     default; jsonl carries `tool_args` but we don't backfill it to avoid
+ *     surprising users who never enabled full-args storage).
+ *   - `decision='warn'` collapses to `'allow'` because audit_logs CHECK
+ *     constraint allows only allow/deny — same as the live handler's behavior
+ *     at routes/hooks.ts (the warn → allow + distinguishing reason fold).
+ *   - `ip` is the loopback address; jsonl is generated client-side and has no
+ *     real remote IP.
+ */
+function telemetryEntryToAuditRecord(entry, hash) {
+    const policyDecision = entry.policy_decision;
+    const decision = policyDecision === 'deny' ? 'deny' : 'allow';
+    const outcome = entry.error
+        ? 'error'
+        : decision === 'deny'
+            ? 'denied'
+            : 'success';
+    const ruleIds = entry.policy_rule_ids ?? [];
+    const reasonParts = [];
+    if (policyDecision === 'warn')
+        reasonParts.push('warn');
+    if (ruleIds.length > 0)
+        reasonParts.push(ruleIds.join(','));
+    const reason = reasonParts.length > 0 ? reasonParts.join(': ') : 'telemetry';
+    // Generate a request ID and use it as the sessionId fallback when the
+    // jsonl entry lacks one — matches the live handler's behavior at
+    // routes/hooks.ts (`sessionId = event.session_id ?? requestId`).
+    const requestId = crypto_1.default.randomUUID();
+    return {
+        requestId,
+        timestamp: entry.timestamp,
+        actor: entry.actor || 'unknown',
+        orgId: entry.org_id || 'default',
+        upstreamId: `ext:${entry.ide_source || 'unknown'}`,
+        tool: entry.tool ?? '__stop__',
+        argsHash: hash(entry.tool_args ?? {}),
+        argsJson: null,
+        decision,
+        reason,
+        latencyMs: entry.duration_ms ?? 0,
+        outcome,
+        responseHash: null,
+        responseJson: null,
+        ip: '127.0.0.1',
+        sessionId: entry.session_id || requestId,
+    };
+}

package/dist/services/data-dir.d.ts

@@ -0,0 +1,7 @@
+/** Default data directory: ~/.oculi/ */
+export declare function defaultDataDir(): string;
+/**
+ * Ensure `dir` exists and is locked down to the current user (chmod 700).
+ * Returns the absolute path. Idempotent.
+ */
+export declare function ensureDataDir(dir: string): string;

package/dist/services/data-dir.js

@@ -0,0 +1,61 @@
+"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.defaultDataDir = defaultDataDir;
+exports.ensureDataDir = ensureDataDir;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/** Default data directory: ~/.oculi/ */
+function defaultDataDir() {
+    return path.join(os.homedir(), '.oculi');
+}
+/**
+ * Ensure `dir` exists and is locked down to the current user (chmod 700).
+ * Returns the absolute path. Idempotent.
+ */
+function ensureDataDir(dir) {
+    const abs = path.resolve(dir);
+    fs.mkdirSync(abs, { recursive: true, mode: 0o700 });
+    // mkdir's `mode` is masked by umask on existing dirs; chmod is the
+    // authoritative fix when the dir was created earlier with a wider mode.
+    try {
+        fs.chmodSync(abs, 0o700);
+    }
+    catch {
+        // Best-effort — chmod can fail on Windows / weird filesystems.
+    }
+    return abs;
+}

package/dist/services/local-policy-templates.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Starter policy template for `oculi init`.
+ *
+ * Stored as a raw YAML string (not an object) so we can include comments
+ * that explain the format to the user.
+ */
+export declare const TEMPLATE_NAMES: readonly ["standard"];
+export type TemplateName = (typeof TEMPLATE_NAMES)[number];
+export declare const templates: Record<TemplateName, string>;

package/dist/services/local-policy-templates.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Starter policy template for `oculi init`.
+ *
+ * Stored as a raw YAML string (not an object) so we can include comments
+ * that explain the format to the user.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templates = exports.TEMPLATE_NAMES = void 0;
+exports.TEMPLATE_NAMES = ['standard'];
+exports.templates = {
+    standard: `# Oculi local policy — standard (sensible defaults)
+#
+# Blocks dangerous shell commands and path traversal.
+# Warns on .env file access and MCP tool calls.
+
+rules:
+  - id: "no-rm-rf"
+    match:
+      tool: shell
+      command_pattern: "rm\\\\s+-rf"
+    action: deny
+
+  - id: "no-path-traversal"
+    match:
+      tool: shell
+      command_pattern: "\\\\.\\\\./"
+    action: deny
+
+  - id: "warn-env-access"
+    match:
+      tool: file_read
+      file_pattern: "\\\\.env"
+    action: warn
+
+  - id: "warn-env-edit"
+    match:
+      tool: file_edit
+      file_pattern: "\\\\.env"
+    action: warn
+
+  - id: "warn-mcp"
+    match:
+      tool: mcp_call
+    action: warn
+`,
+};

package/dist/services/local-policy.d.ts

@@ -0,0 +1,39 @@
+import { OculiEvent } from '../routes/adapters/schema';
+export interface PolicyRuleMatch {
+    tool?: string;
+    command_pattern?: string;
+    file_pattern?: string;
+    mcp_server?: string;
+}
+export interface PolicyRule {
+    id: string;
+    match: PolicyRuleMatch;
+    action: 'deny' | 'warn' | 'allow';
+}
+export interface LocalPolicyFile {
+    rules: PolicyRule[];
+}
+export interface LocalPolicyResult {
+    action: 'deny' | 'warn' | 'allow';
+    matchedRules: PolicyRule[];
+}
+/**
+ * Search for `.oculi/policy.yaml` starting from `startDir`, walking up to
+ * the filesystem root, then falling back to `~/.oculi/policy.yaml`.
+ * Returns the first path found, or null.
+ */
+export declare function findPolicyFile(startDir?: string): string | null;
+/**
+ * Load and parse a policy file. Returns null if the file doesn't exist.
+ * Throws on parse errors so callers can decide how to handle them.
+ */
+export declare function loadPolicyFile(filePath: string): LocalPolicyFile;
+export declare function ruleMatches(rule: PolicyRule, event: OculiEvent): boolean;
+/**
+ * Evaluate local policy rules against a normalized OculiEvent.
+ *
+ * - Only evaluates on `pre` phase events. Post/complete → allow.
+ * - Collects all matching rules, highest-precedence action wins (deny > warn > allow).
+ * - If no rules match → allow.
+ */
+export declare function evaluateLocalPolicy(event: OculiEvent, rules: PolicyRule[]): LocalPolicyResult;