@optimuslabs/harness-map-staging 1.5.16

package/dist/log_config_files/runtime/compliance_session_log.js

@@ -0,0 +1,378 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, appendFileSync, readFileSync, } from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { OPTIMUSLABS_LOGS_REL, LOG_GROUP_COMPLIANCE } from '../../bootstrap_constants.js';
+import { buildLogMetadataBlock } from './log_metadata.js';
+const COMPLIANCE_SUBDIR = LOG_GROUP_COMPLIANCE;
+const TIER_NOOP = 'noop';
+const TIER_SUCCESS = 'success';
+const TIER_FAILURES = 'failures';
+const TIER_IN_PROCESS = 'in_process';
+const TIER_DIRS = [TIER_NOOP, TIER_SUCCESS, TIER_FAILURES];
+/** Server upload contract still uses "error" for failed remediation sessions. */
+const UPLOAD_OUTCOME_ERROR = 'error';
+const NOOP_MAX_AGE_MS = 30 * 60 * 1000;
+const SUCCESS_ERROR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/** In-flight logs in compliance/in_process/ before finalize. */
+const INFLIGHT_MAX_AGE_MS = 2 * 60 * 60 * 1000;
+const LATEST_POINTER = 'latest';
+const MAX_SESSION_LOG_UPLOAD_BYTES = 5 * 1024 * 1024;
+let activeComplianceLogPath = null;
+export function parseComplianceLogArg(argv) {
+    const eq = argv.find((a) => a.startsWith('--compliance-log='));
+    if (eq) {
+        const v = eq.slice('--compliance-log='.length).trim();
+        return v || null;
+    }
+    const idx = argv.indexOf('--compliance-log');
+    if (idx >= 0 && argv[idx + 1]) {
+        const v = argv[idx + 1].trim();
+        return v || null;
+    }
+    return null;
+}
+export function isFinalizeComplianceSessionArgv(argv) {
+    return argv.includes('--finalize-compliance-session');
+}
+export function getComplianceLogDir() {
+    return path.join(homedir(), OPTIMUSLABS_LOGS_REL, COMPLIANCE_SUBDIR);
+}
+export function getActiveComplianceLogPath() {
+    return activeComplianceLogPath;
+}
+export function setActiveComplianceLogPath(logPath) {
+    activeComplianceLogPath = logPath ? path.resolve(logPath) : null;
+}
+function isTierDirName(name) {
+    return TIER_DIRS.includes(name);
+}
+function isManagedDirName(name) {
+    return isTierDirName(name) || name === TIER_IN_PROCESS;
+}
+function getInProcessComplianceLogDir() {
+    return path.join(getComplianceLogDir(), TIER_IN_PROCESS);
+}
+/**
+ * Convert legacy/root session paths into the explicit in_process/ location.
+ *
+ * Hooks may still pass ~/.../compliance/<timestamp>.log; future writes should live
+ * at ~/.../compliance/in_process/<timestamp>.log until finalize classifies them.
+ */
+export function resolveComplianceSessionLogPath(logPath) {
+    const resolved = path.resolve(logPath);
+    if (path.dirname(resolved) === getComplianceLogDir()) {
+        return path.join(getInProcessComplianceLogDir(), path.basename(resolved));
+    }
+    return resolved;
+}
+/** Session log still in compliance/in_process/ (not yet finalized into a tier folder). */
+export function isInflightComplianceLogPath(logPath) {
+    const resolved = resolveComplianceSessionLogPath(logPath);
+    return path.dirname(resolved) === getInProcessComplianceLogDir();
+}
+export function readLatestComplianceLogPointer() {
+    const pointer = path.join(getComplianceLogDir(), LATEST_POINTER);
+    if (!existsSync(pointer))
+        return null;
+    try {
+        const p = readFileSync(pointer, 'utf8').trim();
+        return p || null;
+    }
+    catch {
+        return null;
+    }
+}
+function pruneLogFilesInDir(dir, maxAgeMs, exceptPath) {
+    if (!existsSync(dir))
+        return 0;
+    const cutoff = Date.now() - maxAgeMs;
+    let removed = 0;
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith('.log'))
+            continue;
+        const full = path.join(dir, name);
+        if (exceptPath && full === exceptPath)
+            continue;
+        try {
+            const st = statSync(full);
+            if (st.mtimeMs < cutoff) {
+                unlinkSync(full);
+                removed += 1;
+            }
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return removed;
+}
+export function pruneComplianceSessionLogs(exceptPath) {
+    const base = getComplianceLogDir();
+    const keep = exceptPath ? path.resolve(exceptPath) : null;
+    let removed = 0;
+    removed += pruneLogFilesInDir(path.join(base, TIER_NOOP), NOOP_MAX_AGE_MS, keep);
+    removed += pruneLogFilesInDir(path.join(base, TIER_SUCCESS), SUCCESS_ERROR_MAX_AGE_MS, keep);
+    removed += pruneLogFilesInDir(path.join(base, TIER_FAILURES), SUCCESS_ERROR_MAX_AGE_MS, keep);
+    removed += pruneLogFilesInDir(path.join(base, TIER_IN_PROCESS), INFLIGHT_MAX_AGE_MS, keep);
+    if (!existsSync(base))
+        return removed;
+    for (const name of readdirSync(base)) {
+        if (name === LATEST_POINTER || isManagedDirName(name))
+            continue;
+        if (!name.endsWith('.log'))
+            continue;
+        const full = path.join(base, name);
+        if (keep && full === keep)
+            continue;
+        try {
+            const st = statSync(full);
+            if (st.mtimeMs < Date.now() - INFLIGHT_MAX_AGE_MS) {
+                unlinkSync(full);
+                removed += 1;
+            }
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return removed;
+}
+/**
+ * Classify a compliance session for finalize + optional server upload.
+ *
+ * Only two outcomes are uploaded (success / error on the wire): remediation **succeeded** or **failed**.
+ * Policy violations, in-flight restart, and sync-only sessions are noop (local retention only).
+ */
+export function classifyComplianceSessionLog(content) {
+    const text = content.trim();
+    if (!text)
+        return TIER_NOOP;
+    if (/remediation_tracking: verified uuid=/.test(text)) {
+        return TIER_SUCCESS;
+    }
+    const remediationFailedPatterns = [
+        /REMEDIATION APPLY FAILURE/,
+        /compliance_check_runner: uncaught error/,
+        /remediation_tracking: verification_failed uuid=/,
+        /post_restart_verification count=\d+ quarantined=[1-9]/,
+        /enforceRemediation.*failed/i,
+    ];
+    if (remediationFailedPatterns.some((p) => p.test(text))) {
+        return TIER_FAILURES;
+    }
+    return TIER_NOOP;
+}
+/** Keep at compliance/ root until verify or remediation failure is recorded in the session. */
+export function isRemediationCycleInflight(content) {
+    if (/remediation_tracking: verified uuid=/.test(content))
+        return false;
+    if (/remediation_tracking: verification_failed uuid=/.test(content))
+        return false;
+    if (/REMEDIATION APPLY FAILURE/.test(content))
+        return false;
+    if (/post_restart_verification count=\d+ quarantined=[1-9]/.test(content))
+        return false;
+    return /remediation_tracking: pending_post_restart_verify uuid=/.test(content);
+}
+function ensureComplianceLogDir() {
+    const dir = getComplianceLogDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    for (const tier of [...TIER_DIRS, TIER_IN_PROCESS]) {
+        const sub = path.join(dir, tier);
+        if (!existsSync(sub))
+            mkdirSync(sub, { recursive: true, mode: 0o700 });
+    }
+}
+function writeLatestPointer(logPath) {
+    try {
+        ensureComplianceLogDir();
+        writeFileSync(path.join(getComplianceLogDir(), LATEST_POINTER), `${logPath}\n`, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+function appendComplianceLine(logPath, line) {
+    try {
+        const dir = path.dirname(logPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        appendFileSync(logPath, line, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+export function complianceLogSessionBanner(logPath, label, mode) {
+    const resolved = path.resolve(logPath);
+    const ts = new Date().toISOString();
+    const banner = mode === 'replace'
+        ? `\n${'='.repeat(72)}\n${ts} session: ${label}\n${'='.repeat(72)}\n`
+        : `\n${'-'.repeat(72)}\n${ts} section: ${label}\n${'-'.repeat(72)}\n`;
+    try {
+        const dir = path.dirname(resolved);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (mode === 'replace') {
+            writeFileSync(resolved, banner + buildLogMetadataBlock(), 'utf8');
+        }
+        else {
+            appendFileSync(resolved, banner, 'utf8');
+        }
+        writeLatestPointer(resolved);
+    }
+    catch {
+        // best-effort
+    }
+}
+/** Gate: prune old files, bind path, start or resume an inflight session file. */
+export function initComplianceSessionForGate(logPath) {
+    const resolved = resolveComplianceSessionLogPath(logPath);
+    ensureComplianceLogDir();
+    const removed = pruneComplianceSessionLogs(resolved);
+    setActiveComplianceLogPath(resolved);
+    const resume = existsSync(resolved) && statSync(resolved).size > 0 && isInflightComplianceLogPath(resolved);
+    complianceLogSessionBanner(resolved, 'compliance_prompt_gate (before submit)', resume ? 'append' : 'replace');
+    if (!resume) {
+        writeLatestPointer(resolved);
+    }
+    if (removed > 0) {
+        appendComplianceLine(resolved, `${new Date().toISOString()} compliance_session: pruned ${removed} log(s) (in_process 2h, noop 30m, success/failures 24h)\n`);
+    }
+    return resolved;
+}
+/** Runner: prune old files, bind path, append runner section to the gate session file. */
+export function initComplianceSessionForRunner(logPath) {
+    const resolved = resolveComplianceSessionLogPath(logPath);
+    ensureComplianceLogDir();
+    const removed = pruneComplianceSessionLogs(resolved);
+    setActiveComplianceLogPath(resolved);
+    complianceLogSessionBanner(resolved, 'compliance_check_runner (background sync + check)', 'append');
+    if (removed > 0) {
+        appendComplianceLine(resolved, `${new Date().toISOString()} compliance_session: pruned ${removed} log(s) (in_process 2h, noop 30m, success/failures 24h)\n`);
+    }
+    return resolved;
+}
+/**
+ * Move session log from compliance/ root into noop|success|failures/ and prune tiers.
+ * No-op if file missing or already finalized.
+ */
+export function finalizeComplianceSessionLog(logPath, forcedTier) {
+    const resolved = resolveComplianceSessionLogPath(logPath);
+    if (!existsSync(resolved))
+        return null;
+    const parentName = path.basename(path.dirname(resolved));
+    if (isTierDirName(parentName)) {
+        return { tier: parentName, logPath: resolved, moved: false };
+    }
+    if (parentName === 'error') {
+        return { tier: TIER_FAILURES, logPath: resolved, moved: false };
+    }
+    const content = readFileSync(resolved, 'utf8');
+    if (isRemediationCycleInflight(content)) {
+        return null;
+    }
+    const tier = forcedTier ?? classifyComplianceSessionLog(content);
+    ensureComplianceLogDir();
+    const dest = path.join(getComplianceLogDir(), tier, path.basename(resolved));
+    if (resolved !== dest) {
+        if (existsSync(dest))
+            unlinkSync(dest);
+        renameSync(resolved, dest);
+    }
+    setActiveComplianceLogPath(null);
+    writeLatestPointer(dest);
+    pruneComplianceSessionLogs(dest);
+    return { tier, logPath: dest, moved: true };
+}
+export function appendToActiveComplianceLog(message) {
+    const logPath = activeComplianceLogPath;
+    if (!logPath)
+        return;
+    try {
+        appendComplianceLine(logPath, `${new Date().toISOString()} ${message}\n`);
+    }
+    catch {
+        // best-effort
+    }
+}
+export function readComplianceSessionLog(logPath) {
+    try {
+        if (!existsSync(logPath))
+            return '';
+        return readFileSync(logPath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function appendLineToSessionLogFile(logPath, message) {
+    try {
+        appendComplianceLine(logPath, `${new Date().toISOString()} ${message}\n`);
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Upload full session log to the server (success and failures tiers only, first finalize only).
+ */
+export async function uploadComplianceSessionLogFromFinalize(result) {
+    if (result.tier !== TIER_SUCCESS && result.tier !== TIER_FAILURES)
+        return;
+    if (!result.moved)
+        return;
+    const logText = readComplianceSessionLog(result.logPath);
+    if (!logText.trim())
+        return;
+    const logBytes = Buffer.byteLength(logText, 'utf8');
+    if (logBytes > MAX_SESSION_LOG_UPLOAD_BYTES) {
+        appendLineToSessionLogFile(result.logPath, `compliance_session_upload: skipped (${logBytes} bytes exceeds ${MAX_SESSION_LOG_UPLOAD_BYTES})`);
+        return;
+    }
+    const { readStoredAuthKey } = await import('../auth/auth_key_store.js');
+    const { tryResolveHardwareUuid } = await import('./hardware_uuid.js');
+    const { loadEndpointBase } = await import('../sender/endpoint_config.js');
+    const { createSignature } = await import('../sender/signing.js');
+    const { buildApiUrl } = await import('../../endpoint_client/registry_api.js');
+    const { executeBody } = await import('../../endpoint_client/http_transport.js');
+    const authKey = readStoredAuthKey();
+    const hardwareUuid = tryResolveHardwareUuid();
+    if (!authKey || !hardwareUuid) {
+        appendLineToSessionLogFile(result.logPath, 'compliance_session_upload: skipped (auth key or hardware UUID unavailable)');
+        return;
+    }
+    const sessionFilename = path.basename(result.logPath);
+    const outcome = result.tier === TIER_FAILURES ? UPLOAD_OUTCOME_ERROR : result.tier;
+    const signingPayload = {
+        hardware_uuid: hardwareUuid,
+        outcome,
+        session_filename: sessionFilename,
+        log_text: logText,
+    };
+    const signature = createSignature(signingPayload, authKey.key);
+    const body = JSON.stringify({ ...signingPayload, signature });
+    const url = buildApiUrl(loadEndpointBase(), '/endpoint_security/api/remediation-activity-log/');
+    try {
+        const { statusCode } = await executeBody(url, 'POST', body, 30_000);
+        if (statusCode === 200) {
+            appendLineToSessionLogFile(result.logPath, `compliance_session_upload: ok outcome=${outcome} bytes=${logBytes}`);
+        }
+        else {
+            appendLineToSessionLogFile(result.logPath, `compliance_session_upload: server status=${statusCode}`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        appendLineToSessionLogFile(result.logPath, `compliance_session_upload: failed ${msg}`);
+    }
+}
+/** Finalize session file into success|failures|noop tier, then upload when success or failures. */
+export async function finalizeAndUploadComplianceSessionLog(logPath, forcedTier) {
+    const result = finalizeComplianceSessionLog(logPath, forcedTier);
+    if (result) {
+        await uploadComplianceSessionLogFromFinalize(result);
+    }
+    return result;
+}

package/dist/log_config_files/runtime/dialog_preferences.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { atomicWriteJson, getDialogPreferencesPath, } from './management_storage.js';
+export function readDialogPreferences() {
+    const path = getDialogPreferencesPath();
+    if (!existsSync(path)) {
+        return { version: 1, suppress_non_restart_autofix_dialogs: false };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (parsed?.version !== 1)
+            return { version: 1, suppress_non_restart_autofix_dialogs: false };
+        return {
+            version: 1,
+            suppress_non_restart_autofix_dialogs: Boolean(parsed.suppress_non_restart_autofix_dialogs),
+        };
+    }
+    catch {
+        return { version: 1, suppress_non_restart_autofix_dialogs: false };
+    }
+}
+export function isNonRestartAutofixDialogSuppressed() {
+    return readDialogPreferences().suppress_non_restart_autofix_dialogs === true;
+}
+export function setSuppressNonRestartAutofixDialogs(suppress) {
+    const next = {
+        version: 1,
+        suppress_non_restart_autofix_dialogs: suppress,
+        updated_at: new Date().toISOString(),
+    };
+    atomicWriteJson(getDialogPreferencesPath(), next);
+}

package/dist/log_config_files/runtime/hardware_uuid.js

@@ -0,0 +1,36 @@
+import { execSync } from 'node:child_process';
+/** Resolve hardware UUID from environment or system commands. */
+function resolveHardwareUuid() {
+    const envUuid = process.env.OPTIMUS_HARDWARE_UUID?.trim();
+    if (envUuid)
+        return envUuid;
+    try {
+        const ioregOutput = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { encoding: 'utf8' }).trim();
+        const ioregMatch = ioregOutput.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/i);
+        if (ioregMatch?.[1])
+            return ioregMatch[1];
+    }
+    catch {
+        // try next method
+    }
+    try {
+        const profilerOutput = execSync('system_profiler SPHardwareDataType', { encoding: 'utf8' }).trim();
+        const profilerMatch = profilerOutput.match(/Hardware UUID:\s*([A-F0-9-]+)/i);
+        if (profilerMatch?.[1])
+            return profilerMatch[1];
+    }
+    catch {
+        // both methods failed
+    }
+    throw new Error('Unable to determine hardware UUID via ioreg or system_profiler.');
+}
+/** Same as {@link resolveHardwareUuid} but returns null when the host exposes no stable ID (e.g. Linux CI). */
+export function tryResolveHardwareUuid() {
+    try {
+        return resolveHardwareUuid();
+    }
+    catch {
+        return null;
+    }
+}
+export { resolveHardwareUuid };