@danielblomma/cortex-mcp 2.4.0 → 2.4.2

package/scaffold/mcp/dist/daemon/heartbeat-pusher.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { hostname, platform, release } from "node:os";
+import { loadEnterpriseConfig } from "../core/config.js";
+import { isAllowedEnterpriseEndpoint } from "../core/secure-endpoint.js";
+/**
+ * Govern host heartbeat — fills the host_enrollment table on cortex-web.
+ *
+ * Reads .context/govern.local.json + enterprise.yml + OS info, builds a
+ * canonical payload matching governHeartbeatSchema on the server side,
+ * and POSTs it to /api/v1/govern/heartbeat. Without this, the dashboard
+ * at /dashboard/govern shows zero hosts forever.
+ *
+ * Periodic — default 5 min, same cadence as host-events-pusher.
+ */
+const TIER_BY_CLI = {
+    claude: "prevent",
+    codex: "prevent",
+    copilot: "wrap",
+};
+function readLocalGovernState(cwd) {
+    const p = join(cwd, ".context", "govern.local.json");
+    if (!existsSync(p))
+        return {};
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function mapOs(plat) {
+    if (plat === "darwin")
+        return "darwin";
+    if (plat === "linux")
+        return "linux";
+    if (plat === "win32")
+        return "windows";
+    return "linux";
+}
+export function buildHeartbeatPayload(cwd, hostId) {
+    const config = loadEnterpriseConfig(join(cwd, ".context"));
+    const state = readLocalGovernState(cwd);
+    const installs = state.installs ?? {};
+    const now = new Date().toISOString();
+    const aiClisDetected = Object.entries(installs).map(([name, info]) => ({
+        name,
+        tier: TIER_BY_CLI[name] ?? "off",
+        version: info.version,
+        last_seen: now,
+    }));
+    let governMode = "off";
+    for (const inst of Object.values(installs)) {
+        if (inst.mode === "enforced") {
+            governMode = "enforced";
+            break;
+        }
+        if (inst.mode === "advisory" && governMode === "off")
+            governMode = "advisory";
+    }
+    const configVersion = Object.values(installs)[0]?.version ?? null;
+    return {
+        host_id: hostId ?? hostname(),
+        os: mapOs(platform()),
+        os_version: release(),
+        govern_mode: governMode,
+        active_frameworks: config.compliance.frameworks,
+        config_version: configVersion,
+        ai_clis_detected: aiClisDetected,
+    };
+}
+export async function pushHeartbeat(cwd) {
+    const config = loadEnterpriseConfig(join(cwd, ".context"));
+    const apiKey = config.enterprise.api_key.trim();
+    const baseUrl = (config.enterprise.base_url || config.enterprise.endpoint).trim();
+    if (!apiKey || !baseUrl) {
+        return { ok: false, error: "enterprise not configured" };
+    }
+    if (!isAllowedEnterpriseEndpoint(baseUrl)) {
+        return { ok: false, error: "insecure or invalid enterprise endpoint" };
+    }
+    const payload = buildHeartbeatPayload(cwd);
+    try {
+        const res = await fetch(`${baseUrl.replace(/\/$/, "")}/api/v1/govern/heartbeat`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            return { ok: false, error: `HTTP ${res.status} ${res.statusText}` };
+        }
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function startHeartbeatPusher(cwd, intervalMs) {
+    const tick = () => {
+        void pushHeartbeat(cwd).catch((err) => {
+            process.stderr.write(`[cortex-daemon] heartbeat push failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        });
+    };
+    void Promise.resolve().then(tick);
+    const handle = setInterval(tick, intervalMs);
+    if (typeof handle.unref === "function")
+        handle.unref();
+    return {
+        stop() {
+            clearInterval(handle);
+        },
+    };
+}

package/scaffold/mcp/dist/daemon/heartbeat-tracker.js

@@ -0,0 +1,165 @@
+import { writeFileSync, existsSync, unlinkSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { hostname } from "node:os";
+import { writeHostAuditEvent } from "./ungoverned-scanner.js";
+export const TAMPER_LOCK_FILENAME = ".cortex-tamper.lock";
+export class HeartbeatTracker {
+    sessions = new Map();
+    hostId;
+    cleanupAfterMs;
+    constructor(options = {}) {
+        this.hostId = options.hostId ?? hostname();
+        // Sessions with no heartbeat for this long are auto-removed (covers
+        // crashes that never sent SessionEnd). Default 12h.
+        this.cleanupAfterMs = options.cleanupAfterMs ?? 12 * 60 * 60 * 1000;
+    }
+    recordHeartbeat(payload) {
+        const existing = this.sessions.get(payload.session_id);
+        const now = payload.ts;
+        if (payload.hook === "SessionStart") {
+            this.sessions.set(payload.session_id, {
+                cli: payload.cli,
+                cwd: payload.cwd,
+                started_at: now,
+                last_heartbeat: now,
+                hook_count: 1,
+                ended: false,
+            });
+        }
+        else if (payload.hook === "SessionEnd") {
+            if (existing) {
+                existing.last_heartbeat = now;
+                existing.ended = true;
+                existing.ended_at = now;
+                existing.hook_count += 1;
+            }
+            else {
+                // SessionEnd without prior SessionStart — register a closed session
+                // so the tamper-checker doesn't flag it later.
+                this.sessions.set(payload.session_id, {
+                    cli: payload.cli,
+                    cwd: payload.cwd,
+                    started_at: now,
+                    last_heartbeat: now,
+                    hook_count: 1,
+                    ended: true,
+                    ended_at: now,
+                });
+            }
+        }
+        else {
+            if (existing) {
+                existing.last_heartbeat = now;
+                existing.hook_count += 1;
+            }
+            else {
+                // Heartbeat from a session we never saw start (daemon was restarted
+                // mid-session). Register it as active.
+                this.sessions.set(payload.session_id, {
+                    cli: payload.cli,
+                    cwd: payload.cwd,
+                    started_at: now,
+                    last_heartbeat: now,
+                    hook_count: 1,
+                    ended: false,
+                });
+            }
+        }
+        const tamperLockActive = existsSync(join(payload.cwd, ".context", TAMPER_LOCK_FILENAME));
+        return { recorded: true, tamper_lock_active: tamperLockActive };
+    }
+    getActiveSessions() {
+        return Array.from(this.sessions.entries()).filter(([, state]) => !state.ended);
+    }
+    detectTamper(options) {
+        const now = options.now ?? new Date();
+        const thresholdMs = options.missingThresholdSeconds * 1000;
+        const flagged = [];
+        const allowedCwds = new Set(options.cwds);
+        for (const [sessionId, state] of this.sessions) {
+            // Cleanup sessions that have been silent forever — they crashed.
+            const lastMs = new Date(state.last_heartbeat).getTime();
+            if (Number.isFinite(lastMs) && now.getTime() - lastMs > this.cleanupAfterMs) {
+                this.sessions.delete(sessionId);
+                continue;
+            }
+            if (state.ended)
+                continue;
+            if (!allowedCwds.has(state.cwd))
+                continue;
+            // Need at least 2 heartbeats for the "had-activity-then-silence"
+            // signal — a single SessionStart followed by silence may just be a
+            // user opening Claude and walking away.
+            if (state.hook_count < 2)
+                continue;
+            const elapsedMs = now.getTime() - lastMs;
+            if (elapsedMs <= thresholdMs)
+                continue;
+            const entry = {
+                version: 1,
+                detected_at: now.toISOString(),
+                cli: state.cli,
+                session_id: sessionId,
+                hook_name: "any",
+                last_seen: state.last_heartbeat,
+                missing_seconds: Math.round(elapsedMs / 1000),
+                host_id: this.hostId,
+                cwd: state.cwd,
+            };
+            flagged.push(entry);
+            // Mark ended so we don't re-flag the same session every tick.
+            state.ended = true;
+            state.ended_at = now.toISOString();
+            options.onTamperDetected?.(entry);
+        }
+        return flagged;
+    }
+    // For tests:
+    _forceState(sessionId, state) {
+        this.sessions.set(sessionId, state);
+    }
+    _size() {
+        return this.sessions.size;
+    }
+}
+export function writeTamperLock(cwd, entry) {
+    const dir = join(cwd, ".context");
+    const path = join(dir, TAMPER_LOCK_FILENAME);
+    writeFileSync(path, JSON.stringify(entry, null, 2) + "\n", "utf8");
+    return path;
+}
+export function readTamperLock(cwd) {
+    const path = join(cwd, ".context", TAMPER_LOCK_FILENAME);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function removeTamperLock(cwd) {
+    const path = join(cwd, ".context", TAMPER_LOCK_FILENAME);
+    if (!existsSync(path))
+        return false;
+    try {
+        unlinkSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function emitTamperAudit(cwd, entry) {
+    await writeHostAuditEvent(cwd, {
+        event_type: "hook_tamper_detected",
+        timestamp: entry.detected_at,
+        host_id: entry.host_id,
+        cli: entry.cli,
+        session_id: entry.session_id,
+        hook_name: entry.hook_name,
+        last_seen: entry.last_seen,
+        missing_seconds: entry.missing_seconds,
+    });
+}

package/scaffold/mcp/dist/daemon/host-events-pusher.js

@@ -0,0 +1,249 @@
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync, statSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { loadEnterpriseConfig } from "../core/config.js";
+import { isAllowedEnterpriseEndpoint } from "../core/secure-endpoint.js";
+/**
+ * Phase 7 sync flow — host-events pusher.
+ *
+ * The daemon writes ungoverned-session and hook-tamper events to
+ * .context/audit/host-events-YYYY-MM-DD.jsonl. This pusher batches
+ * unpushed events and POSTs them to the cortex-web govern endpoints.
+ *
+ * State (.context/.cortex-host-events-cursor.json) tracks the last
+ * pushed timestamp per event_type so we don't double-push or skip.
+ */
+const CURSOR_FILENAME = ".cortex-host-events-cursor.json";
+/**
+ * Cursor format is `${ISO_TIMESTAMP}#${stable_id}` where stable_id is
+ * the pid for ungoverned events and the session_id for tamper events.
+ * The composite suffix breaks ties when two writers emit at the exact
+ * same millisecond (clock resolution / two daemon producers).
+ *
+ * For backward compatibility, a persisted value with no `#` is treated
+ * as `${ts}#~`: `~` sorts after every printable ASCII character we
+ * actually emit, so an old cursor still skips all events at-or-before
+ * its timestamp on the first read after upgrade.
+ */
+function readCursor(cwd) {
+    const path = join(cwd, ".context", CURSOR_FILENAME);
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeCursor(value) {
+    if (!value)
+        return undefined;
+    return value.includes("#") ? value : `${value}#~`;
+}
+function stableIdFor(evt) {
+    if (evt.event_type === "ungoverned_ai_session_detected") {
+        const pid = evt.pid;
+        if (typeof pid === "number")
+            return String(pid);
+        if (typeof pid === "string" && pid.length > 0)
+            return pid;
+        return "0";
+    }
+    if (evt.event_type === "hook_tamper_detected") {
+        const sid = evt.session_id;
+        if (typeof sid === "string" && sid.length > 0)
+            return sid;
+        return "";
+    }
+    return "";
+}
+function compositeKey(evt) {
+    const ts = eventTimestamp(evt);
+    if (!ts)
+        return null;
+    return `${ts}#${stableIdFor(evt)}`;
+}
+function sortByTs(arr) {
+    return arr.sort((a, b) => {
+        const ka = compositeKey(a) ?? "";
+        const kb = compositeKey(b) ?? "";
+        if (ka < kb)
+            return -1;
+        if (ka > kb)
+            return 1;
+        return 0;
+    });
+}
+function writeCursor(cwd, cursor) {
+    const path = join(cwd, ".context", CURSOR_FILENAME);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(cursor, null, 2) + "\n", "utf8");
+}
+function listHostEventFiles(cwd) {
+    const dir = join(cwd, ".context", "audit");
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.startsWith("host-events-") && name.endsWith(".jsonl"))
+        .sort()
+        .map((name) => join(dir, name));
+}
+function readEventsFrom(file) {
+    if (!existsSync(file))
+        return [];
+    const stat = statSync(file);
+    if (!stat.isFile())
+        return [];
+    const raw = readFileSync(file, "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return out;
+}
+function eventTimestamp(e) {
+    const ts = e.timestamp ?? e.detected_at;
+    return typeof ts === "string" ? ts : null;
+}
+function isAfterComposite(evt, cursor) {
+    if (!cursor)
+        return true;
+    const key = compositeKey(evt);
+    if (!key)
+        return false;
+    return key > cursor;
+}
+export async function pushHostEvents(cwd) {
+    const outcome = {
+        ungoverned_pushed: 0,
+        tamper_pushed: 0,
+        errors: [],
+    };
+    const config = loadEnterpriseConfig(join(cwd, ".context"));
+    const apiKey = config.enterprise.api_key.trim();
+    const baseUrl = (config.enterprise.base_url || config.enterprise.endpoint).trim();
+    if (!apiKey || !baseUrl) {
+        outcome.errors.push("enterprise not configured");
+        return outcome;
+    }
+    if (!isAllowedEnterpriseEndpoint(baseUrl)) {
+        outcome.errors.push("insecure or invalid enterprise endpoint");
+        return outcome;
+    }
+    const cursor = readCursor(cwd);
+    const ungovernedCursor = normalizeCursor(cursor.ungoverned_last_ts);
+    const tamperCursor = normalizeCursor(cursor.tamper_last_ts);
+    const ungoverned = [];
+    const tamper = [];
+    for (const file of listHostEventFiles(cwd)) {
+        for (const evt of readEventsFrom(file)) {
+            const ts = eventTimestamp(evt);
+            if (!ts)
+                continue;
+            if (evt.event_type === "ungoverned_ai_session_detected" && isAfterComposite(evt, ungovernedCursor)) {
+                ungoverned.push(evt);
+            }
+            else if (evt.event_type === "hook_tamper_detected" && isAfterComposite(evt, tamperCursor)) {
+                tamper.push(evt);
+            }
+        }
+    }
+    sortByTs(ungoverned);
+    sortByTs(tamper);
+    if (ungoverned.length > 0) {
+        const result = await pushBatch(`${baseUrl.replace(/\/$/, "")}/api/v1/govern/ungoverned`, apiKey, {
+            events: ungoverned.map(toUngovernedPayload),
+        });
+        if (result.ok) {
+            outcome.ungoverned_pushed = ungoverned.length;
+            const last = ungoverned[ungoverned.length - 1];
+            cursor.ungoverned_last_ts = compositeKey(last) ?? cursor.ungoverned_last_ts;
+        }
+        else {
+            outcome.errors.push(`ungoverned: ${result.error}`);
+        }
+    }
+    if (tamper.length > 0) {
+        const result = await pushBatch(`${baseUrl.replace(/\/$/, "")}/api/v1/govern/tamper`, apiKey, {
+            events: tamper.map(toTamperPayload),
+        });
+        if (result.ok) {
+            outcome.tamper_pushed = tamper.length;
+            const last = tamper[tamper.length - 1];
+            cursor.tamper_last_ts = compositeKey(last) ?? cursor.tamper_last_ts;
+        }
+        else {
+            outcome.errors.push(`tamper: ${result.error}`);
+        }
+    }
+    if (outcome.ungoverned_pushed > 0 || outcome.tamper_pushed > 0) {
+        writeCursor(cwd, cursor);
+    }
+    return outcome;
+}
+function toUngovernedPayload(e) {
+    return {
+        detected_at: e.timestamp,
+        host_id: e.host_id,
+        cli: e.cli,
+        binary_path: e.binary,
+        args: e.args,
+        sys_user: e.user,
+        parent_pid: e.ppid,
+        pid: e.pid,
+        action_taken: e.action ?? "logged",
+    };
+}
+function toTamperPayload(e) {
+    return {
+        detected_at: e.timestamp,
+        host_id: e.host_id,
+        cli: e.cli,
+        hook_name: e.hook_name ?? "any",
+        session_id: e.session_id,
+        last_seen: e.last_seen ?? null,
+        missing_seconds: e.missing_seconds,
+    };
+}
+async function pushBatch(url, apiKey, payload) {
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            return { ok: false, error: `HTTP ${res.status} ${res.statusText}` };
+        }
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function startHostEventsPusher(cwd, intervalMs) {
+    const tick = () => {
+        void pushHostEvents(cwd).catch((err) => {
+            process.stderr.write(`[cortex-daemon] host-events push failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        });
+    };
+    void Promise.resolve().then(tick);
+    const handle = setInterval(tick, intervalMs);
+    if (typeof handle.unref === "function")
+        handle.unref();
+    return {
+        stop() {
+            clearInterval(handle);
+        },
+    };
+}