@danielblomma/cortex-mcp 2.4.0 → 2.4.2

package/scaffold/mcp/dist/daemon/client.js

@@ -0,0 +1,130 @@
+import { connect } from "node:net";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { socketPath, pidFilePath, logFilePath } from "./paths.js";
+import { DEFAULT_REQUEST_TIMEOUT_MS, } from "./protocol.js";
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+function readDaemonPid() {
+    if (!existsSync(pidFilePath()))
+        return null;
+    try {
+        const raw = readFileSync(pidFilePath(), "utf8").trim();
+        const pid = Number.parseInt(raw, 10);
+        if (!Number.isFinite(pid) || pid <= 0)
+            return null;
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export function isDaemonRunning() {
+    const pid = readDaemonPid();
+    if (pid === null)
+        return false;
+    return isProcessAlive(pid);
+}
+/**
+ * Spawn the daemon as a detached process. Returns immediately — caller is
+ * responsible for waiting until socket is ready (typically via retry loop).
+ */
+export function spawnDaemon(daemonEntryAbsPath) {
+    const out = (() => {
+        try {
+            // openSync returns an fd we can pass to spawn for stdio redirection.
+            // Append-only — the daemon log accumulates across runs.
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const fs = require("node:fs");
+            return fs.openSync(logFilePath(), "a");
+        }
+        catch {
+            return "ignore";
+        }
+    })();
+    const child = spawn(process.execPath, [daemonEntryAbsPath], {
+        detached: true,
+        stdio: ["ignore", out, out],
+        env: { ...process.env, CORTEX_DAEMON_AUTOSTART: "1" },
+    });
+    child.unref();
+}
+async function connectWithRetry(timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const sock = await new Promise((resolve) => {
+            const s = connect(socketPath());
+            s.once("connect", () => resolve(s));
+            s.once("error", () => {
+                s.destroy();
+                resolve(null);
+            });
+        });
+        if (sock)
+            return sock;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    return null;
+}
+export async function call(type, payload, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const id = randomUUID();
+    const sock = await connectWithRetry(timeoutMs);
+    if (!sock) {
+        return { ok: false, error: "daemon_unreachable" };
+    }
+    return new Promise((resolve) => {
+        let buffer = "";
+        let settled = false;
+        const finish = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            sock.end();
+            resolve(r);
+        };
+        const timer = setTimeout(() => {
+            finish({ ok: false, error: "timeout" });
+        }, timeoutMs);
+        timer.unref();
+        sock.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            const nl = buffer.indexOf("\n");
+            if (nl === -1)
+                return;
+            const line = buffer.slice(0, nl);
+            try {
+                const resp = JSON.parse(line);
+                if (resp.id !== id)
+                    return; // not ours; ignore
+                clearTimeout(timer);
+                if (resp.ok) {
+                    finish({ ok: true, result: resp.result });
+                }
+                else {
+                    finish({ ok: false, error: resp.error ?? "unknown_error" });
+                }
+            }
+            catch {
+                finish({ ok: false, error: "invalid_response" });
+            }
+        });
+        sock.on("error", (err) => {
+            clearTimeout(timer);
+            finish({ ok: false, error: `socket_error: ${err.message}` });
+        });
+        const request = { id, type, payload };
+        sock.write(`${JSON.stringify(request)}\n`);
+    });
+}

package/scaffold/mcp/dist/daemon/egress-proxy.js

@@ -0,0 +1,288 @@
+import { createServer, connect } from "node:net";
+import { hostname } from "node:os";
+import { writeHostAuditEvent } from "./ungoverned-scanner.js";
+/**
+ * Phase 4 task 19 — cortex egress proxy.
+ *
+ * Listens on a local TCP port for HTTP CONNECT (https-proxy) requests.
+ * Pipes bytes through transparently; does NOT terminate TLS. Inspects
+ * only:
+ *   - the CONNECT line for the destination host:port
+ *   - the first client chunk for the TLS ClientHello SNI extension
+ *
+ * Per privacy boundary v3 we never send payload bytes to cortex-web —
+ * only SNI + destination + bytes-transferred counters. The audit lands
+ * in .context/audit/host-events-YYYY-MM-DD.jsonl as event_type =
+ * "egress_connection" only when a caller supplies an attributable project
+ * cwd. The shared daemon proxy intentionally omits cwd and therefore emits
+ * no project audit record rather than misattributing cross-project traffic.
+ *
+ * Plain HTTP (non-CONNECT) is also supported but logged with the Host
+ * header in place of SNI.
+ */
+const CONNECT_RE = /^CONNECT\s+([^\s:]+):(\d+)\s+HTTP\/1\.[01]/i;
+const HTTP_RE = /^([A-Z]+)\s+(http:\/\/[^\s]+)\s+HTTP\/1\.[01]/i;
+/**
+ * Parse SNI from a TLS ClientHello buffer. Returns null if not found
+ * or buffer is malformed. Does not mutate the buffer.
+ */
+export function parseSni(buf) {
+    if (buf.length < 11)
+        return null;
+    if (buf[0] !== 0x16)
+        return null;
+    if (buf[1] !== 0x03)
+        return null;
+    const recordLen = buf.readUInt16BE(3);
+    const recordEnd = 5 + recordLen;
+    if (buf.length < recordEnd)
+        return null;
+    if (buf[5] !== 0x01)
+        return null;
+    const handshakeLen = (buf[6] << 16) | (buf[7] << 8) | buf[8];
+    const handshakeEnd = 9 + handshakeLen;
+    if (buf.length < Math.min(handshakeEnd, recordEnd))
+        return null;
+    let p = 9 + 2 + 32;
+    if (p + 1 > recordEnd)
+        return null;
+    const sessionIdLen = buf[p];
+    p += 1 + sessionIdLen;
+    if (p + 2 > recordEnd)
+        return null;
+    const cipherSuitesLen = buf.readUInt16BE(p);
+    p += 2 + cipherSuitesLen;
+    if (p + 1 > recordEnd)
+        return null;
+    const compMethodsLen = buf[p];
+    p += 1 + compMethodsLen;
+    if (p + 2 > recordEnd)
+        return null;
+    const extensionsLen = buf.readUInt16BE(p);
+    p += 2;
+    const extensionsEnd = p + extensionsLen;
+    if (extensionsEnd > recordEnd)
+        return null;
+    while (p + 4 <= extensionsEnd) {
+        const extType = buf.readUInt16BE(p);
+        const extLen = buf.readUInt16BE(p + 2);
+        const extEnd = p + 4 + extLen;
+        if (extEnd > extensionsEnd)
+            return null;
+        if (extType === 0x0000) {
+            let q = p + 4;
+            if (q + 2 > extEnd)
+                return null;
+            const listLen = buf.readUInt16BE(q);
+            q += 2;
+            const listEnd = q + listLen;
+            if (listEnd > extEnd)
+                return null;
+            while (q + 3 <= listEnd) {
+                const nameType = buf[q];
+                const nameLen = buf.readUInt16BE(q + 1);
+                q += 3;
+                if (q + nameLen > listEnd)
+                    return null;
+                if (nameType === 0x00) {
+                    return buf.subarray(q, q + nameLen).toString("ascii");
+                }
+                q += nameLen;
+            }
+            return null;
+        }
+        p = extEnd;
+    }
+    return null;
+}
+const HTTP_OK = "HTTP/1.1 200 Connection Established\r\nProxy-Agent: cortex-egress\r\n\r\n";
+const HTTP_BAD = "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n";
+const HTTP_BAD_GATEWAY = "HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n";
+function emit(cwd, evt) {
+    if (!cwd)
+        return;
+    void writeHostAuditEvent(cwd, evt).catch((err) => {
+        process.stderr.write(`[cortex-egress] audit emit failed: ${err instanceof Error ? err.message : String(err)}\n`);
+    });
+}
+function newEvent(host, port, protocol, hostId, sourcePort) {
+    return {
+        event_type: "egress_connection",
+        timestamp: new Date().toISOString(),
+        host_id: hostId,
+        source_port: sourcePort,
+        destination: { host, port },
+        protocol,
+        sni: null,
+        bytes_client_to_server: 0,
+        bytes_server_to_client: 0,
+        duration_ms: 0,
+        closed_by: "client",
+        error: null,
+    };
+}
+function pipeWithCounting(client, upstream, evt, cwd, start) {
+    let firstClientChunk = true;
+    client.on("data", (chunk) => {
+        evt.bytes_client_to_server += chunk.length;
+        if (firstClientChunk && evt.protocol === "https") {
+            firstClientChunk = false;
+            const sni = parseSni(chunk);
+            if (sni)
+                evt.sni = sni;
+        }
+        upstream.write(chunk);
+    });
+    upstream.on("data", (chunk) => {
+        evt.bytes_server_to_client += chunk.length;
+        client.write(chunk);
+    });
+    const finalize = (closer, error = null) => {
+        if (evt.duration_ms > 0)
+            return;
+        evt.duration_ms = Date.now() - start;
+        evt.closed_by = closer;
+        evt.error = error;
+        emit(cwd, evt);
+        try {
+            client.destroy();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            upstream.destroy();
+        }
+        catch {
+            // ignore
+        }
+    };
+    client.on("end", () => finalize("client"));
+    upstream.on("end", () => finalize("server"));
+    client.on("error", (err) => finalize("error", err.message));
+    upstream.on("error", (err) => finalize("error", err.message));
+}
+function handleConnect(client, host, port, cwd, hostId) {
+    const evt = newEvent(host, port, "https", hostId, client.remotePort ?? null);
+    const start = Date.now();
+    const upstream = connect({ host, port }, () => {
+        client.write(HTTP_OK);
+        pipeWithCounting(client, upstream, evt, cwd, start);
+    });
+    upstream.on("error", (err) => {
+        evt.duration_ms = Date.now() - start;
+        evt.closed_by = "error";
+        evt.error = `upstream connect: ${err.message}`;
+        emit(cwd, evt);
+        try {
+            client.write(HTTP_BAD_GATEWAY);
+            client.destroy();
+        }
+        catch {
+            // ignore
+        }
+    });
+}
+function handleHttp(client, url, initialChunk, cwd, hostId) {
+    const port = url.port ? parseInt(url.port, 10) : 80;
+    const evt = newEvent(url.hostname, port, "http", hostId, client.remotePort ?? null);
+    evt.sni = url.hostname;
+    const start = Date.now();
+    const upstream = connect({ host: url.hostname, port }, () => {
+        upstream.write(initialChunk);
+        pipeWithCounting(client, upstream, evt, cwd, start);
+    });
+    upstream.on("error", (err) => {
+        evt.duration_ms = Date.now() - start;
+        evt.closed_by = "error";
+        evt.error = `upstream connect: ${err.message}`;
+        emit(cwd, evt);
+        try {
+            client.write(HTTP_BAD_GATEWAY);
+            client.destroy();
+        }
+        catch {
+            // ignore
+        }
+    });
+}
+function handleConnection(client, cwd, hostId) {
+    let buffer = Buffer.alloc(0);
+    const onFirstChunk = (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        if (headerEnd === -1) {
+            if (buffer.length > 8192) {
+                client.write(HTTP_BAD);
+                client.destroy();
+                return;
+            }
+            client.once("data", onFirstChunk);
+            return;
+        }
+        const headers = buffer.subarray(0, headerEnd).toString("ascii");
+        const remainder = buffer.subarray(headerEnd + 4);
+        const firstLine = headers.split(/\r?\n/, 1)[0] ?? "";
+        const connectMatch = firstLine.match(CONNECT_RE);
+        if (connectMatch) {
+            const host = connectMatch[1];
+            const port = parseInt(connectMatch[2], 10);
+            handleConnect(client, host, port, cwd, hostId);
+            return;
+        }
+        const httpMatch = firstLine.match(HTTP_RE);
+        if (httpMatch) {
+            let url;
+            try {
+                url = new URL(httpMatch[2]);
+            }
+            catch {
+                client.write(HTTP_BAD);
+                client.destroy();
+                return;
+            }
+            const path = url.pathname + url.search;
+            const rebuilt = `${httpMatch[1]} ${path} HTTP/1.1\r\n${headers.split(/\r?\n/).slice(1).join("\r\n")}\r\n\r\n`;
+            const initial = Buffer.concat([Buffer.from(rebuilt, "ascii"), remainder]);
+            handleHttp(client, url, initial, cwd, hostId);
+            return;
+        }
+        client.write(HTTP_BAD);
+        client.destroy();
+    };
+    client.once("data", onFirstChunk);
+    client.on("error", () => {
+        try {
+            client.destroy();
+        }
+        catch {
+            // ignore
+        }
+    });
+}
+export function startEgressProxy(options) {
+    const port = options.port ?? 18888;
+    const hostId = options.hostId ?? hostname();
+    const cwd = options.cwd;
+    return new Promise((resolve, reject) => {
+        const server = createServer((client) => handleConnection(client, cwd, hostId));
+        server.once("error", (err) => {
+            reject(err);
+        });
+        server.listen(port, "127.0.0.1", () => {
+            const addr = server.address();
+            const actualPort = typeof addr === "object" && addr ? addr.port : port;
+            let running = true;
+            resolve({
+                port: actualPort,
+                async stop() {
+                    if (!running)
+                        return;
+                    running = false;
+                    await new Promise((res) => server.close(() => res()));
+                },
+                isRunning: () => running,
+            });
+        });
+    });
+}

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

@@ -0,0 +1,222 @@
+import { chmodSync, closeSync, constants, existsSync, fchmodSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { loadEnterpriseConfig } from "../core/config.js";
+import { enterpriseCredentialId, isAllowedLicenseEndpoint, } from "../core/license.js";
+import { matchesEnterpriseHostIdentity } from "../core/enterprise-host-identity.js";
+const EVENT_FILE_RE = /^ungoverned-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const CURSOR_FILENAME = "global-host-events-cursor.json";
+function configuredHome() {
+    return process.env.HOME?.trim() || homedir();
+}
+function globalEventDir(create) {
+    try {
+        const home = realpathSync(configuredHome());
+        const cortexDir = join(home, ".cortex");
+        if (!existsSync(cortexDir))
+            return null;
+        const cortexStat = lstatSync(cortexDir);
+        if (!cortexStat.isDirectory() || cortexStat.isSymbolicLink())
+            return null;
+        if (realpathSync(cortexDir) !== cortexDir)
+            return null;
+        const dir = join(cortexDir, "host-events");
+        if (existsSync(dir)) {
+            const stat = lstatSync(dir);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                return null;
+            if (realpathSync(dir) !== dir)
+                return null;
+            chmodSync(dir, 0o700);
+            return dir;
+        }
+        if (!create)
+            return null;
+        mkdirSync(dir, { mode: 0o700 });
+        chmodSync(dir, 0o700);
+        return dir;
+    }
+    catch {
+        return null;
+    }
+}
+function eventKey(event) {
+    const pid = typeof event.pid === "number" || typeof event.pid === "string"
+        ? String(event.pid)
+        : "0";
+    return `${event.timestamp}#${pid}`;
+}
+export function writeGlobalUngovernedEvent(credentialId, event) {
+    if (!matchesEnterpriseHostIdentity(credentialId))
+        return false;
+    const dir = globalEventDir(true);
+    if (!dir)
+        return false;
+    const date = new Date().toISOString().slice(0, 10);
+    const path = join(dir, `ungoverned-${date}.jsonl`);
+    let fd = null;
+    try {
+        fd = openSync(path, constants.O_WRONLY |
+            constants.O_APPEND |
+            constants.O_CREAT |
+            constants.O_NOFOLLOW, 0o600);
+        fchmodSync(fd, 0o600);
+        writeSync(fd, JSON.stringify({ ...event, credential_id: credentialId }) + "\n", undefined, "utf8");
+        closeSync(fd);
+        return true;
+    }
+    catch {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Best effort.
+            }
+        }
+        return false;
+    }
+}
+function readCursor(dir, credentialId) {
+    const path = join(dir, CURSOR_FILENAME);
+    try {
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            return { version: 1, credential_id: credentialId };
+        }
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (parsed.version !== 1 ||
+            parsed.credential_id !== credentialId ||
+            (parsed.ungoverned_last_key !== undefined &&
+                typeof parsed.ungoverned_last_key !== "string")) {
+            return { version: 1, credential_id: credentialId };
+        }
+        return parsed;
+    }
+    catch {
+        return { version: 1, credential_id: credentialId };
+    }
+}
+function writeCursor(dir, cursor) {
+    const path = join(dir, CURSOR_FILENAME);
+    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporaryPath, JSON.stringify(cursor, null, 2) + "\n", { encoding: "utf8", mode: 0o600, flag: "wx" });
+        chmodSync(temporaryPath, 0o600);
+        renameSync(temporaryPath, path);
+        chmodSync(path, 0o600);
+    }
+    catch (err) {
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // Best effort.
+        }
+        throw err;
+    }
+}
+function readEvents(dir, credentialId) {
+    const events = [];
+    for (const name of readdirSync(dir).filter((entry) => EVENT_FILE_RE.test(entry)).sort()) {
+        const path = join(dir, name);
+        try {
+            const stat = lstatSync(path);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                continue;
+            for (const line of readFileSync(path, "utf8").split("\n")) {
+                if (!line.trim())
+                    continue;
+                const parsed = JSON.parse(line);
+                if (parsed.event_type !== "ungoverned_ai_session_detected" ||
+                    parsed.credential_id !== credentialId ||
+                    typeof parsed.timestamp !== "string") {
+                    continue;
+                }
+                events.push(parsed);
+            }
+        }
+        catch {
+            // Skip malformed or concurrently changing files.
+        }
+    }
+    return events.sort((a, b) => eventKey(a).localeCompare(eventKey(b)));
+}
+export async function pushGlobalUngovernedEvents(cwd, credentialId) {
+    if (!matchesEnterpriseHostIdentity(credentialId)) {
+        return { pushed: 0, error: "enterprise identity conflict" };
+    }
+    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 ||
+        !isAllowedLicenseEndpoint(baseUrl) ||
+        enterpriseCredentialId(baseUrl, apiKey) !== credentialId) {
+        return { pushed: 0, error: "enterprise identity conflict" };
+    }
+    const dir = globalEventDir(false);
+    if (!dir)
+        return { pushed: 0 };
+    const cursor = readCursor(dir, credentialId);
+    const events = readEvents(dir, credentialId).filter((event) => !cursor.ungoverned_last_key ||
+        eventKey(event) > cursor.ungoverned_last_key);
+    if (events.length === 0)
+        return { pushed: 0 };
+    try {
+        const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/v1/govern/ungoverned`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                events: events.map((event) => ({
+                    detected_at: event.timestamp,
+                    host_id: event.host_id,
+                    cli: event.cli,
+                    binary_path: event.binary,
+                    args: event.args,
+                    sys_user: event.user,
+                    parent_pid: event.ppid,
+                    pid: event.pid,
+                    action_taken: event.action ?? "logged",
+                })),
+            }),
+        });
+        if (!response.ok) {
+            return {
+                pushed: 0,
+                error: `HTTP ${response.status} ${response.statusText}`,
+            };
+        }
+        cursor.ungoverned_last_key = eventKey(events[events.length - 1]);
+        writeCursor(dir, cursor);
+        return { pushed: events.length };
+    }
+    catch (err) {
+        return {
+            pushed: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function startGlobalUngovernedEventsPusher(cwd, credentialId, intervalMs) {
+    const tick = () => {
+        void pushGlobalUngovernedEvents(cwd, credentialId).then((outcome) => {
+            if (outcome.error) {
+                process.stderr.write(`[cortex-daemon] global host-events push failed: ${outcome.error}\n`);
+            }
+        });
+    };
+    void Promise.resolve().then(tick);
+    const handle = setInterval(tick, intervalMs);
+    if (typeof handle.unref === "function")
+        handle.unref();
+    return {
+        stop() {
+            clearInterval(handle);
+        },
+    };
+}