@danielblomma/cortex-mcp 2.4.0 → 2.4.2

package/scaffold/mcp/dist/daemon/sync-checker.js

@@ -0,0 +1,165 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { hostname } from "node:os";
+import { join } from "node:path";
+import { loadEnterpriseConfig } from "../core/config.js";
+import { isAllowedEnterpriseEndpoint } from "../core/secure-endpoint.js";
+import { writeHostAuditEvent } from "./ungoverned-scanner.js";
+/**
+ * Phase 7 sync flow — daemon side.
+ *
+ * The daemon periodically pings cortex-web /api/v1/govern/config to learn
+ * whether a new config version is available. It does NOT re-apply (that
+ * would require root, which the daemon explicitly doesn't have post-Fas-3
+ * privilege drop). Instead it emits an audit event and writes a
+ * notification file that 'cortex enterprise status' surfaces. The
+ * operator must then run 'sudo cortex enterprise sync' to actually
+ * re-fetch + write managed-settings.
+ *
+ * Three audit outcomes per tick:
+ *  - govern_config_unchanged  (304 / same version) — heartbeat that
+ *                              cortex-web is reachable and we're current.
+ *  - govern_config_available  (200 with new version) — operator action needed.
+ *  - govern_config_sync_failed (network / auth error) — also written so
+ *                              admin sees blackouts in audit timeline.
+ */
+const NOTIFICATION_FILENAME = ".govern-update-available.json";
+function readLocalGovernState(cwd) {
+    const path = join(cwd, ".context", "govern.local.json");
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function activeFrameworks(cwd) {
+    const state = readLocalGovernState(cwd);
+    for (const inst of Object.values(state.installs ?? {})) {
+        if (inst.frameworks?.length) {
+            return inst.frameworks.map((f) => f.id);
+        }
+    }
+    // Fall back to enterprise.yml's compliance.frameworks
+    const config = loadEnterpriseConfig(join(cwd, ".context"));
+    return config.compliance.frameworks;
+}
+function currentVersion(cwd, cli) {
+    const state = readLocalGovernState(cwd);
+    return state.installs?.[cli]?.version ?? null;
+}
+export async function checkSyncForCli(options) {
+    const cwd = options.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 { kind: "failed", error: "enterprise not configured" };
+    }
+    if (!isAllowedEnterpriseEndpoint(baseUrl)) {
+        return { kind: "failed", error: "insecure or invalid enterprise endpoint" };
+    }
+    const frameworks = activeFrameworks(cwd);
+    if (frameworks.length === 0) {
+        return { kind: "failed", error: "no active frameworks" };
+    }
+    const url = new URL(baseUrl.replace(/\/$/, "") + "/api/v1/govern/config");
+    url.searchParams.set("cli", options.cli);
+    url.searchParams.set("frameworks", frameworks.join(","));
+    const installedVersion = currentVersion(cwd, options.cli);
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+    };
+    if (installedVersion)
+        headers["If-None-Match"] = `"${installedVersion}"`;
+    let res;
+    try {
+        res = await fetch(url, { headers });
+    }
+    catch (err) {
+        return { kind: "failed", error: err instanceof Error ? err.message : String(err) };
+    }
+    if (res.status === 304) {
+        return { kind: "unchanged", version: installedVersion ?? "unknown" };
+    }
+    if (!res.ok) {
+        return { kind: "failed", error: `HTTP ${res.status} ${res.statusText}` };
+    }
+    const etag = (res.headers.get("etag") ?? "").replace(/"/g, "");
+    if (etag && etag === installedVersion) {
+        return { kind: "unchanged", version: etag };
+    }
+    return {
+        kind: "available",
+        latest_version: etag || "unknown",
+        current_version: installedVersion,
+    };
+}
+function writeUpdateNotification(cwd, data) {
+    const dir = join(cwd, ".context");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, NOTIFICATION_FILENAME), JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+export async function runSyncCheckOnce(cwd, clis) {
+    const outcomes = [];
+    const now = new Date().toISOString();
+    for (const cli of clis) {
+        const outcome = await checkSyncForCli({ cwd, cli });
+        outcomes.push(outcome);
+        const eventBase = {
+            timestamp: now,
+            host_id: hostname(),
+            cli,
+        };
+        if (outcome.kind === "unchanged") {
+            await writeHostAuditEvent(cwd, {
+                ...eventBase,
+                event_type: "govern_config_unchanged",
+                version: outcome.version,
+            }).catch(() => undefined);
+        }
+        else if (outcome.kind === "available") {
+            await writeHostAuditEvent(cwd, {
+                ...eventBase,
+                event_type: "govern_config_available",
+                latest_version: outcome.latest_version,
+                current_version: outcome.current_version,
+            }).catch(() => undefined);
+            writeUpdateNotification(cwd, {
+                latest_version: outcome.latest_version,
+                current_version: outcome.current_version,
+                cli,
+                detected_at: now,
+            });
+        }
+        else {
+            await writeHostAuditEvent(cwd, {
+                ...eventBase,
+                event_type: "govern_config_sync_failed",
+                error: outcome.error,
+            }).catch(() => undefined);
+        }
+    }
+    return outcomes;
+}
+export function startSyncTimer(cwd, intervalMs) {
+    const tick = () => {
+        const state = readLocalGovernState(cwd);
+        const clis = Object.keys(state.installs ?? {});
+        if (clis.length === 0)
+            return;
+        void runSyncCheckOnce(cwd, clis).catch((err) => {
+            process.stderr.write(`[cortex-daemon] sync check 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/ungoverned-scanner.js

@@ -0,0 +1,136 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { platform, userInfo } from "node:os";
+import { detectUngoverned, enforceFinding, } from "../cli/ungoverned-detector.js";
+import { writeGlobalUngovernedEvent } from "./global-host-events.js";
+import { getGovernManagedPath } from "../core/govern-paths.js";
+const DEFAULT_INTERVAL_MS = 60_000;
+const TIER1_CLIS = new Set(["claude", "codex"]);
+function readMode(cwd) {
+    const stateFile = join(cwd, ".context", "govern.local.json");
+    if (!existsSync(stateFile))
+        return "advisory";
+    try {
+        const raw = readFileSync(stateFile, "utf8");
+        const parsed = JSON.parse(raw);
+        for (const inst of Object.values(parsed.installs ?? {})) {
+            if (inst.mode === "enforced")
+                return "enforced";
+        }
+        return "advisory";
+    }
+    catch {
+        return "advisory";
+    }
+}
+function isExpectedManagedArtifact(cli, path) {
+    try {
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return false;
+        const raw = readFileSync(path, "utf8");
+        if (cli === "codex") {
+            return raw.startsWith("# Cortex govern — codex requirements");
+        }
+        const parsed = JSON.parse(raw);
+        return parsed.allowManagedHooksOnly === true;
+    }
+    catch {
+        return false;
+    }
+}
+function readManagedTier1Clis(cwd, overrides) {
+    const stateFile = join(cwd, ".context", "govern.local.json");
+    const managed = new Set();
+    if (!existsSync(stateFile))
+        return managed;
+    try {
+        const raw = readFileSync(stateFile, "utf8");
+        const parsed = JSON.parse(raw);
+        for (const [cli, inst] of Object.entries(parsed.installs ?? {})) {
+            if (!TIER1_CLIS.has(cli))
+                continue;
+            const tier1Cli = cli;
+            const expectedPath = overrides?.[tier1Cli] ??
+                getGovernManagedPath(tier1Cli, platform());
+            if (!isExpectedManagedArtifact(tier1Cli, expectedPath)) {
+                continue;
+            }
+            managed.add(cli);
+        }
+    }
+    catch {
+        return managed;
+    }
+    return managed;
+}
+function filterManagedTier1Findings(findings, managedTier1Clis) {
+    if (managedTier1Clis.size === 0)
+        return findings;
+    return findings.filter((finding) => !managedTier1Clis.has(finding.cli));
+}
+export async function writeHostAuditEvent(cwd, event) {
+    const auditDir = join(cwd, ".context", "audit");
+    await mkdir(auditDir, { recursive: true });
+    const date = new Date().toISOString().slice(0, 10);
+    const file = join(auditDir, `host-events-${date}.jsonl`);
+    await appendFile(file, JSON.stringify(event) + "\n");
+}
+export async function runScanOnce(options) {
+    const mode = options.mode ?? readMode(options.cwd);
+    const managedTier1Clis = readManagedTier1Clis(options.cwd, options.managedPathOverrides);
+    const findings = filterManagedTier1Findings(detectUngoverned(options.detectorOptions), managedTier1Clis);
+    const me = userInfo().username;
+    for (const finding of findings) {
+        const action = enforceFinding(finding, { mode, currentUser: me });
+        // A host process snapshot has no trustworthy project attribution. Store
+        // it only in the credential-bound user-global queue; never in whichever
+        // project happened to register first.
+        if (options.credentialId) {
+            writeGlobalUngovernedEvent(options.credentialId, {
+                event_type: "ungoverned_ai_session_detected",
+                timestamp: finding.detected_at,
+                host_id: finding.host_id,
+                cli: finding.cli,
+                binary: finding.binary,
+                pid: finding.pid,
+                ppid: finding.ppid,
+                user: finding.user,
+                args: finding.args,
+                parent_chain: finding.parent_chain,
+                mode,
+                action,
+            });
+        }
+        options.onFinding?.({ ...finding, action });
+    }
+    return findings;
+}
+export function startUngovernedScanner(options) {
+    const interval = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    let running = true;
+    const tick = async () => {
+        if (!running)
+            return;
+        try {
+            await runScanOnce(options);
+        }
+        catch (err) {
+            process.stderr.write(`[cortex-daemon] ungoverned scan failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    };
+    void tick();
+    const handle = setInterval(() => void tick(), interval);
+    if (typeof handle.unref === "function")
+        handle.unref();
+    return {
+        stop() {
+            running = false;
+            clearInterval(handle);
+        },
+        isRunning() {
+            return running;
+        },
+    };
+}

package/scaffold/mcp/dist/daemon/workflow-sync-checker.js

@@ -0,0 +1,249 @@
+import { existsSync, readFileSync, writeFileSync, } from "node:fs";
+import { hostname } from "node:os";
+import { join } from "node:path";
+import { loadEnterpriseConfig } from "../core/config.js";
+import { matchesEnterpriseHostIdentity } from "../core/enterprise-host-identity.js";
+import { enterpriseCredentialId, isAllowedLicenseEndpoint, } from "../core/license.js";
+import { workflowDefinitionSchema } from "../core/workflow/schemas.js";
+import { writeHostAuditEvent } from "./ungoverned-scanner.js";
+import { daemonDir } from "./paths.js";
+/**
+ * Org-workflow sync flow — daemon side.
+ *
+ * The daemon polls cortex-web /api/v1/govern/workflows/manifest each tick
+ * to learn what workflows the org has authored. It diffs against a local
+ * state file, fetches changed full definitions, and caches them locally.
+ * cortex.workflow.start (and the cortex stage CLI) read the cache via
+ * loadSyncedWorkflows() and merge with bundled DEFAULT_WORKFLOWS, with
+ * org definitions taking precedence on workflow_id collisions.
+ *
+ * Three audit outcomes per tick:
+ *  - workflows_unchanged   — manifest matches local state
+ *  - workflows_synced      — at least one workflow was added / changed /
+ *                            removed (metadata: counts)
+ *  - workflows_sync_failed — network / auth / parse error
+ *
+ * Unlike skills, there is no on-disk artifact to write per workflow —
+ * the cached JSON is the only product. No "restart Claude Code"
+ * notification is needed because workflow lookup happens at run-start.
+ */
+const STATE_FILENAME = "workflows.local.json";
+function stateFilePath() {
+    return join(daemonDir(), STATE_FILENAME);
+}
+export function readSyncedWorkflowsState() {
+    const path = stateFilePath();
+    if (!existsSync(path))
+        return { workflows: {} };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return {
+            credential_id: typeof parsed.credential_id === "string"
+                ? parsed.credential_id
+                : undefined,
+            workflows: parsed.workflows ?? {},
+            last_synced_at: parsed.last_synced_at,
+        };
+    }
+    catch {
+        return { workflows: {} };
+    }
+}
+function writeSyncedWorkflowsState(state) {
+    writeFileSync(stateFilePath(), JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+async function fetchManifest(baseUrl, apiKey) {
+    const url = new URL(baseUrl.replace(/\/$/, "") + "/api/v1/govern/workflows/manifest");
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    return body.workflows ?? [];
+}
+async function fetchWorkflow(baseUrl, apiKey, workflowId) {
+    const url = new URL(baseUrl.replace(/\/$/, "") +
+        "/api/v1/govern/workflows/" +
+        encodeURIComponent(workflowId));
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    if (!body.workflow) {
+        throw new Error(`Response for ${workflowId} missing 'workflow' field`);
+    }
+    return body.workflow;
+}
+export async function runWorkflowSyncOnce(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) {
+        const outcome = {
+            kind: "failed",
+            error: "enterprise not configured",
+        };
+        await writeAudit(cwd, outcome);
+        return outcome;
+    }
+    if (!isAllowedLicenseEndpoint(baseUrl)) {
+        const outcome = {
+            kind: "failed",
+            error: "insecure or invalid enterprise endpoint",
+        };
+        await writeAudit(cwd, outcome);
+        return outcome;
+    }
+    const credentialId = enterpriseCredentialId(baseUrl, apiKey);
+    if (!matchesEnterpriseHostIdentity(credentialId)) {
+        const outcome = {
+            kind: "failed",
+            error: "enterprise identity conflict: this user profile is already enrolled to another endpoint or API key",
+        };
+        await writeAudit(cwd, outcome);
+        return outcome;
+    }
+    const state = readSyncedWorkflowsState();
+    const identityChanged = state.credential_id !== credentialId;
+    state.credential_id = credentialId;
+    let manifest;
+    try {
+        manifest = await fetchManifest(baseUrl, apiKey);
+    }
+    catch (err) {
+        const outcome = {
+            kind: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+        await writeAudit(cwd, outcome);
+        return outcome;
+    }
+    const remoteByName = new Map(manifest.map((e) => [e.workflow_id, e]));
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const entry of manifest) {
+        const local = state.workflows[entry.workflow_id];
+        const isNew = !local;
+        const isChanged = Boolean(local) &&
+            (identityChanged ||
+                local.updated_at !== entry.updated_at ||
+                local.version !== entry.version);
+        if (!isNew && !isChanged)
+            continue;
+        let fetched;
+        try {
+            fetched = await fetchWorkflow(baseUrl, apiKey, entry.workflow_id);
+        }
+        catch (err) {
+            const outcome = {
+                kind: "failed",
+                error: err instanceof Error
+                    ? `fetch ${entry.workflow_id}: ${err.message}`
+                    : `fetch ${entry.workflow_id}: ${String(err)}`,
+            };
+            await writeAudit(cwd, outcome);
+            return outcome;
+        }
+        let validated;
+        try {
+            validated = workflowDefinitionSchema.parse(fetched.definition);
+        }
+        catch (err) {
+            const outcome = {
+                kind: "failed",
+                error: err instanceof Error
+                    ? `validate ${entry.workflow_id}: ${err.message}`
+                    : `validate ${entry.workflow_id}: ${String(err)}`,
+            };
+            await writeAudit(cwd, outcome);
+            return outcome;
+        }
+        state.workflows[entry.workflow_id] = {
+            workflow_id: entry.workflow_id,
+            version: fetched.version,
+            updated_at: fetched.updated_at,
+            definition: validated,
+        };
+        (isNew ? added : changed).push(entry.workflow_id);
+    }
+    for (const name of Object.keys(state.workflows)) {
+        if (remoteByName.has(name))
+            continue;
+        delete state.workflows[name];
+        removed.push(name);
+    }
+    const totalChanged = added.length + changed.length + removed.length;
+    if (totalChanged === 0) {
+        if (identityChanged) {
+            state.last_synced_at = new Date().toISOString();
+            writeSyncedWorkflowsState(state);
+        }
+        const outcome = {
+            kind: "unchanged",
+            count: manifest.length,
+        };
+        await writeAudit(cwd, outcome);
+        return outcome;
+    }
+    state.last_synced_at = new Date().toISOString();
+    writeSyncedWorkflowsState(state);
+    const outcome = {
+        kind: "synced",
+        added,
+        changed,
+        removed,
+    };
+    await writeAudit(cwd, outcome);
+    return outcome;
+}
+async function writeAudit(cwd, outcome) {
+    const eventBase = {
+        timestamp: new Date().toISOString(),
+        host_id: hostname(),
+    };
+    if (outcome.kind === "unchanged") {
+        await writeHostAuditEvent(cwd, {
+            ...eventBase,
+            event_type: "workflows_unchanged",
+            count: outcome.count,
+        }).catch(() => undefined);
+    }
+    else if (outcome.kind === "synced") {
+        await writeHostAuditEvent(cwd, {
+            ...eventBase,
+            event_type: "workflows_synced",
+            added: outcome.added,
+            changed: outcome.changed,
+            removed: outcome.removed,
+        }).catch(() => undefined);
+    }
+    else {
+        await writeHostAuditEvent(cwd, {
+            ...eventBase,
+            event_type: "workflows_sync_failed",
+            error: outcome.error,
+        }).catch(() => undefined);
+    }
+}
+export function startWorkflowSyncTimer(cwd, intervalMs) {
+    const tick = () => {
+        void runWorkflowSyncOnce(cwd).catch((err) => {
+            process.stderr.write(`[cortex-daemon] workflow sync 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/defaults.js

@@ -0,0 +1,6 @@
+export const TRUST_DOCUMENT = 50;
+export const TRUST_CHUNK = 60;
+export const TRUST_MEMORY = 70;
+export const TRUST_CHUNK_RYUGRAPH = 80;
+export const TRUST_RULE = 95;
+export const TRUST_ADR = 95;