@optimuslabs/harness-map-staging 1.5.16

package/dist/log_config_files/runtime/hook_logger.js

@@ -0,0 +1,267 @@
+import { existsSync, mkdirSync, appendFileSync, writeFileSync, statSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { OPTIMUSLABS_LOGS_REL, LOG_GROUP_HOOK, LOG_GROUP_COMPLIANCE, } from '../../bootstrap_constants.js';
+import { getActiveComplianceLogPath } from './compliance_session_log.js';
+import { buildLogMetadataBlock, formatErrorBlock } from './log_metadata.js';
+const HOOK_LOG_FILENAME = 'hook_log.txt';
+const COMPLIANCE_RUNNER_LOG_FILENAME = 'compliance_runner.log';
+const COMPLIANCE_FALLBACK_TIER = 'noop';
+/** Hard cap so a single upload/sync session cannot grow hook_log.txt without bound. */
+const MAX_HOOK_LOG_BYTES = 2 * 1024 * 1024;
+function getHookLogPath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir)
+        return null;
+    return path.join(homeDir, OPTIMUSLABS_LOGS_REL, LOG_GROUP_HOOK, HOOK_LOG_FILENAME);
+}
+function getComplianceRunnerLogPath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir)
+        return null;
+    return path.join(homeDir, OPTIMUSLABS_LOGS_REL, LOG_GROUP_COMPLIANCE, COMPLIANCE_FALLBACK_TIER, COMPLIANCE_RUNNER_LOG_FILENAME);
+}
+/**
+ * Append one ISO-timestamped line to the active compliance session log.
+ * If no session is active, use compliance/noop/compliance_runner.log as a legacy fallback.
+ * `level` examples: INFO, RUNNER, RESTART, FAIL
+ */
+function appendComplianceRunnerLine(level, message) {
+    const sessionPath = getActiveComplianceLogPath();
+    if (sessionPath) {
+        try {
+            appendFileSync(sessionPath, `${new Date().toISOString()} [${level}] pid=${process.pid} ${message}\n`, 'utf8');
+        }
+        catch {
+            // best-effort
+        }
+        return;
+    }
+    const logPath = getComplianceRunnerLogPath();
+    if (!logPath)
+        return;
+    try {
+        const dir = path.dirname(logPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const ts = new Date().toISOString();
+        appendFileSync(logPath, `${ts} [${level}] pid=${process.pid} ${message}\n`, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Append-only diagnostics for remediation sync / compliance (structured).
+ */
+function complianceRunnerDiag(message) {
+    appendComplianceRunnerLine('INFO', message);
+}
+/**
+ * Background compliance_check_runner should use this so entries match the same format.
+ */
+function complianceRunnerRunnerLine(message) {
+    appendComplianceRunnerLine('RUNNER', message);
+}
+/**
+ * Loud record when a remediation cannot be verified or applied. Writes the block to the active
+ * compliance session log (which finalizes into the failures/ tier), and appends a single summary
+ * line to hook_log.txt for the current session. No separate permanent ledger — the failure detail
+ * lives in the per-session compliance log.
+ */
+function logRemediationApplyFailure(context, fields) {
+    const ts = new Date().toISOString();
+    const bodyLines = Object.entries(fields)
+        .filter(([, v]) => v !== undefined && v !== null && String(v) !== '')
+        .map(([k, v]) => `  ${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`);
+    const block = [
+        '',
+        '='.repeat(72),
+        `${ts} REMEDIATION APPLY FAILURE — ${context}`,
+        ...bodyLines,
+        '='.repeat(72),
+        '',
+    ].join('\n');
+    const summary = fields.reason != null
+        ? String(fields.reason)
+        : fields.message != null
+            ? String(fields.message)
+            : 'see fields above';
+    const writeFailAppend = (filePath) => {
+        const dir = path.dirname(filePath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        appendFileSync(filePath, block, 'utf8');
+    };
+    try {
+        const activeCompliancePath = getActiveComplianceLogPath();
+        if (activeCompliancePath) {
+            writeFailAppend(activeCompliancePath);
+        }
+        else {
+            const crPath = getComplianceRunnerLogPath();
+            if (crPath) {
+                const dir = path.dirname(crPath);
+                if (!existsSync(dir))
+                    mkdirSync(dir, { recursive: true, mode: 0o700 });
+                appendFileSync(crPath, block, 'utf8');
+            }
+        }
+    }
+    catch {
+        /* best-effort */
+    }
+    try {
+        hookRunLog(`REMEDIATION_APPLY_FAILURE [${context}] ${fields.uuid != null ? `uuid=${fields.uuid} ` : ''}${summary}`);
+    }
+    catch {
+        /* best-effort */
+    }
+    appendComplianceRunnerLine('FAIL', `${context} — ${summary}`);
+}
+function ensureHookLogUnderCap() {
+    const logPath = getHookLogPath();
+    if (!logPath || !existsSync(logPath))
+        return;
+    try {
+        if (statSync(logPath).size <= MAX_HOOK_LOG_BYTES)
+            return;
+        const ts = new Date().toISOString();
+        writeFileSync(logPath, `${'='.repeat(72)}\n${ts} hook_log.txt truncated (exceeded ${MAX_HOOK_LOG_BYTES} bytes)\n${'='.repeat(72)}\n`, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Start a new hook_log.txt session (replaces the file). Use once per logical run
+ * (e.g. compliance_prompt_gate, log_config_files upload via hookLogReplace).
+ */
+function hookLogSessionBanner(label) {
+    const logPath = getHookLogPath();
+    if (!logPath)
+        return;
+    try {
+        const dir = path.dirname(logPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const ts = new Date().toISOString();
+        const banner = `\n${'='.repeat(72)}\n${ts} session: ${label}\n${'='.repeat(72)}\n`;
+        writeFileSync(logPath, banner + buildLogMetadataBlock(), 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Record a structured error block to the active compliance session log (if any) or
+ * hook_log.txt. Prefer this over silent best-effort catches so failures carry the
+ * error name/message/stack needed to diagnose a customer report.
+ */
+function hookLogError(context, err, fields) {
+    const block = formatErrorBlock(context, err, fields);
+    const compliancePath = getActiveComplianceLogPath();
+    const logPath = compliancePath ?? getHookLogPath();
+    if (!logPath)
+        return;
+    try {
+        const dir = path.dirname(logPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (!compliancePath)
+            ensureHookLogUnderCap();
+        appendFileSync(logPath, block, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Append a subsection after an existing session (e.g. compliance_check_runner after the gate)
+ * without replacing hook_log.txt.
+ */
+function hookLogAppendSection(label) {
+    const compliancePath = getActiveComplianceLogPath();
+    if (compliancePath) {
+        try {
+            const ts = new Date().toISOString();
+            const banner = `\n${'-'.repeat(72)}\n${ts} section: ${label}\n${'-'.repeat(72)}\n`;
+            appendFileSync(compliancePath, banner, 'utf8');
+        }
+        catch {
+            // best-effort
+        }
+        return;
+    }
+    const logPath = getHookLogPath();
+    if (!logPath)
+        return;
+    try {
+        ensureHookLogUnderCap();
+        const dir = path.dirname(logPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const ts = new Date().toISOString();
+        const banner = `\n${'-'.repeat(72)}\n${ts} section: ${label}\n${'-'.repeat(72)}\n`;
+        appendFileSync(logPath, banner, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/** Begins a log_config_files upload session (replaces hook_log.txt, same as hookLogSessionBanner). */
+function hookLogReplace() {
+    hookLogSessionBanner('log_config_files (config upload)');
+}
+/** Append a timestamped line to hook_log.txt or the active compliance session log. */
+function hookRunLog(message) {
+    const compliancePath = getActiveComplianceLogPath();
+    if (compliancePath) {
+        try {
+            const ts = new Date().toISOString();
+            appendFileSync(compliancePath, `${ts} ${message}\n`, 'utf8');
+        }
+        catch {
+            // best-effort
+        }
+        return;
+    }
+    const logPath = getHookLogPath();
+    if (!logPath)
+        return;
+    try {
+        ensureHookLogUnderCap();
+        const ts = new Date().toISOString();
+        appendFileSync(logPath, `${ts} ${message}\n`, 'utf8');
+    }
+    catch {
+        // best-effort; don't break the run
+    }
+}
+/** Append a line without timestamp (for multi-line blocks like manifests). */
+function hookLogLine(message) {
+    const logPath = getHookLogPath();
+    if (!logPath)
+        return;
+    try {
+        ensureHookLogUnderCap();
+        appendFileSync(logPath, `${message}\n`, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/** Read the current hook_log.txt content. Returns empty string if not found or unreadable. */
+function readHookLog() {
+    const logPath = getHookLogPath();
+    if (!logPath)
+        return '';
+    try {
+        if (!existsSync(logPath))
+            return '';
+        return readFileSync(logPath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export { getHookLogPath, getComplianceRunnerLogPath, hookLogReplace, hookLogSessionBanner, hookLogAppendSection, hookRunLog, hookLogError, hookLogLine, complianceRunnerDiag, complianceRunnerRunnerLine, appendComplianceRunnerLine, logRemediationApplyFailure, readHookLog, };

package/dist/log_config_files/runtime/hook_type_for_request.js

@@ -0,0 +1,30 @@
+function normalizeToken(raw) {
+    if (!raw?.trim())
+        return '';
+    const s = raw.trim().toLowerCase().replace(/-/g, '_');
+    if (s === 'claude_desktop')
+        return 'claude';
+    if (s === 'github_copilot')
+        return 'copilot';
+    if (s === 'cursor' || s === 'claude' || s === 'copilot' || s === 'opencode' || s === 'codex')
+        return s;
+    // Legacy hooks set OPTIMUS_AGENT=Cursor (display casing)
+    if (raw.trim() === 'Cursor')
+        return 'cursor';
+    return s;
+}
+/** Resolve hook_request.hook_type from hook wrapper env (OPTIMUS_HOOK_TYPE, then OPTIMUS_AGENT). */
+export function resolveHookTypeFromEnv(env = process.env) {
+    const fromHook = normalizeToken(env.OPTIMUS_HOOK_TYPE);
+    const fromAgent = normalizeToken(env.OPTIMUS_AGENT);
+    const token = fromHook || fromAgent || 'claude';
+    if (token === 'cursor')
+        return 'cursor';
+    if (token === 'copilot')
+        return 'copilot';
+    if (token === 'opencode')
+        return 'opencode';
+    if (token === 'codex')
+        return 'codex';
+    return 'claude';
+}

package/dist/log_config_files/runtime/log_metadata.js

@@ -0,0 +1,122 @@
+/**
+ * Shared log enrichment helpers: a host/run-context metadata block appended to
+ * session banners, and a structured error block. Kept dependency-free of
+ * hook_logger / compliance_session_log so both can import it without cycles.
+ */
+import os from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { OPTIMUSLABS_MANAGEMENT_REL } from '../../bootstrap_constants.js';
+/** This package's name + version as "<name>: <version>", read from its own package.json. */
+function readPackageVersion() {
+    try {
+        const pkgPath = fileURLToPath(new URL('../../../package.json', import.meta.url));
+        const parsed = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        const name = typeof parsed?.name === 'string' ? parsed.name : '';
+        const version = typeof parsed?.version === 'string' ? parsed.version : '';
+        if (name && version)
+            return `${name}: ${version}`;
+        return version || name || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** Deployed bundle version from release/bundle-version.json, or 'unknown'. */
+function readBundleVersion() {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home)
+        return 'unknown';
+    const p = path.join(home, OPTIMUSLABS_MANAGEMENT_REL, 'release', 'bundle-version.json');
+    try {
+        if (!existsSync(p))
+            return 'unknown';
+        const parsed = JSON.parse(readFileSync(p, 'utf8'));
+        return typeof parsed?.version === 'string' ? parsed.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Object form of the host/run-context metadata, for JSON telemetry sent to the backend
+ * (client-event ingest). Same fields as {@link buildLogMetadataBlock}, minus empty values.
+ */
+export function buildLogMetadataObject() {
+    const out = {};
+    const add = (key, value) => {
+        if (value !== undefined && value !== '')
+            out[key] = value;
+    };
+    add('host', os.hostname());
+    add('platform', `${process.platform}/${process.arch}`);
+    add('os_release', os.release());
+    add('node', process.version);
+    add('pid', String(process.pid));
+    add('hook_type', process.env.OPTIMUS_HOOK_TYPE);
+    add('hook_script_version', process.env.OPTIMUS_HOOK_SCRIPT_VERSION);
+    add('reporter_version', readPackageVersion());
+    add('bundle_version', readBundleVersion());
+    add('endpoint', process.env.OPTIMUS_ENDPOINT);
+    add('cwd', process.cwd());
+    return out;
+}
+/**
+ * Indented, multi-line metadata describing the host and run context. Appended to each
+ * session banner so a single log file is self-describing during customer support triage.
+ * Lines with no value are omitted.
+ */
+export function buildLogMetadataBlock() {
+    const lines = ['meta:'];
+    const add = (key, value) => {
+        if (value !== undefined && value !== '')
+            lines.push(`  ${key}=${value}`);
+    };
+    add('host', os.hostname());
+    add('platform', `${process.platform}/${process.arch}`);
+    add('os_release', os.release());
+    add('node', process.version);
+    add('pid', String(process.pid));
+    add('hook_type', process.env.OPTIMUS_HOOK_TYPE);
+    add('hook_script_version', process.env.OPTIMUS_HOOK_SCRIPT_VERSION);
+    add('reporter_version', readPackageVersion());
+    add('bundle_version', readBundleVersion());
+    add('endpoint', process.env.OPTIMUS_ENDPOINT);
+    add('cwd', process.cwd());
+    // Only the banner line + meta: header would be useless on its own; require ≥1 field.
+    return lines.length > 1 ? lines.join('\n') + '\n' : '';
+}
+/**
+ * Structured, multi-line error block: name/message, a trimmed stack, and any extra
+ * context fields. Used by log writers so errors carry enough detail to diagnose
+ * without re-running, instead of being swallowed by best-effort catches.
+ */
+export function formatErrorBlock(context, err, fields) {
+    const ts = new Date().toISOString();
+    const lines = ['', '-'.repeat(72), `${ts} ERROR — ${context}`];
+    if (err instanceof Error) {
+        lines.push(`  error: ${err.name}: ${err.message}`);
+        if (err.stack) {
+            const frames = err.stack
+                .split('\n')
+                .slice(1, 6)
+                .map((l) => `    ${l.trim()}`)
+                .filter((l) => l.trim().length > 0);
+            if (frames.length)
+                lines.push('  stack:', ...frames);
+        }
+    }
+    else {
+        lines.push(`  error: ${String(err)}`);
+    }
+    if (fields) {
+        for (const [k, v] of Object.entries(fields)) {
+            if (v !== undefined && v !== null && String(v) !== '') {
+                lines.push(`  ${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`);
+            }
+        }
+    }
+    lines.push('-'.repeat(72), '');
+    return lines.join('\n');
+}