@optimuslabs/harness-map-staging 1.5.16

package/dist/compliance_prompt_gate.js

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+/**
+ * Synchronous pre-prompt gate: local compliance only (stdout = single JSON line for IDE hooks).
+ * stderr must stay clean; logs go via hookRunLog (compliance session file when --compliance-log is set).
+ *
+ * When autofix returns restart_commands, this process does not spawn them — the shell hook pipes
+ * the same JSON line to execute_trusted_restarts (TS allowlist + spawn).
+ */
+import { applyAutofixViolations, confirmAppliedAutofixVerified, normalizeAgentToken, pruneSatisfiedOneTimeRemediations, reportCompliantRemediationVerifiedStatus, reportPostRestartVerificationOutcomes, runLocalRemediationComplianceCheck, uploadSatisfiedManifestConfigs, } from './log_config_files/runtime/compliance_check.js';
+import { isRemediationQuarantined } from './log_config_files/runtime/remediation_apply_tracking.js';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { getRemediationInstructionsPath } from './log_config_files/runtime/management_storage.js';
+import { hookLogSessionBanner, hookRunLog, logRemediationApplyFailure } from './log_config_files/runtime/hook_logger.js';
+import { getStoryId, bufferFunctionalRun } from './log_config_files/runtime/client_event_reporter.js';
+import { finalizeAndUploadComplianceSessionLog, initComplianceSessionForGate, parseComplianceLogArg, } from './log_config_files/runtime/compliance_session_log.js';
+import { isThisCliModule } from './cli_invocation_match.js';
+import { ensureAuthentication } from './log_config_files/auth/auth_flow.js';
+import { sendConfigFile } from './log_config_files/sender/batch_sender.js';
+import { parseJsonWithJsoncFallback } from './log_config_files/readers/file_readers.js';
+import { PORTABLE_CURSOR_USER_SETTINGS, resolveRemediationConfigPath, resolveRemediationUploadFileType, } from './log_config_files/runtime/remediation_config_path.js';
+import { tryResolveHardwareUuid } from './log_config_files/runtime/hardware_uuid.js';
+import { cursorAutofixDefersInlineVerify, syncRemediations, } from './log_config_files/runtime/remediation_sync.js';
+import { loadEndpointBase } from './log_config_files/sender/endpoint_config.js';
+import { formatRemediationChangePreviewForApplied } from './remediation_change_preview.js';
+const MANIFEST_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+/** After verified (or failed verify), push enforcement + session log immediately — do not wait for background runner. */
+async function flushRemediationOutcomeToServer(complianceLogPath) {
+    if (!complianceLogPath)
+        return;
+    try {
+        await finalizeAndUploadComplianceSessionLog(complianceLogPath);
+    }
+    catch (err) {
+        hookRunLog(`compliance_prompt_gate: session finalize/upload failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function parseIde() {
+    const eq = process.argv.find((a) => a.startsWith('--ide='));
+    if (eq) {
+        const v = eq.slice('--ide='.length).toLowerCase();
+        if (v === 'claude')
+            return 'claude';
+        if (v === 'copilot')
+            return 'copilot';
+        if (v === 'opencode')
+            return 'opencode';
+        return 'cursor';
+    }
+    if (process.argv.includes('--claude'))
+        return 'claude';
+    return 'cursor';
+}
+function defaultAgentFromIde(ide) {
+    if (ide === 'copilot')
+        return 'copilot';
+    if (ide === 'opencode')
+        return 'opencode';
+    return ide === 'claude' ? 'claude' : 'cursor';
+}
+function parseAgent(ide) {
+    const eq = process.argv.find((a) => a.startsWith('--agent='));
+    if (eq) {
+        const normalized = normalizeAgentToken(eq.slice('--agent='.length));
+        if (normalized)
+            return normalized;
+    }
+    return defaultAgentFromIde(ide);
+}
+function printAllow(ide) {
+    if (ide === 'claude' || ide === 'copilot' || ide === 'opencode')
+        console.log('{}');
+    else
+        console.log(JSON.stringify({ continue: true }));
+}
+function printAllowWithAdvisory(ide, advisoryMessage) {
+    if (ide === 'claude' || ide === 'copilot' || ide === 'opencode') {
+        console.log(JSON.stringify({ __optimus_advisory: true, advisory_message: advisoryMessage }));
+    }
+    else {
+        console.log(JSON.stringify({
+            continue: true,
+            __optimus_advisory: true,
+            advisory_message: advisoryMessage,
+        }));
+    }
+}
+function blockPayload(ide, violationMessage) {
+    const prefix = 'Prompt blocked by Optimus: ';
+    const text = prefix + violationMessage;
+    if (ide === 'claude' || ide === 'copilot' || ide === 'opencode') {
+        return JSON.stringify({ decision: 'block', reason: text, systemMessage: text });
+    }
+    return JSON.stringify({ continue: false, user_message: text });
+}
+function getManifestStalenessMs() {
+    try {
+        const path = getRemediationInstructionsPath();
+        if (!existsSync(path))
+            return null;
+        const st = statSync(path);
+        return Date.now() - st.mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function isRunAsCliModule() {
+    return isThisCliModule(process.argv[1], import.meta.url);
+}
+/** Short line for success dialog: finding title/sentence from manifest, not per-check remediation technical text. */
+function autofixDialogLine(v) {
+    const title = v.finding_title?.trim();
+    if (title)
+        return `• [${v.finding_formatted_id}] ${title}`;
+    const fd = v.finding_description?.trim();
+    if (fd)
+        return `• [${v.finding_formatted_id}] ${fd}`;
+    const d = v.description.trim();
+    const short = d.length > 160 ? `${d.slice(0, 157)}…` : d;
+    return `• [${v.finding_formatted_id}] ${short}`;
+}
+/** Ruleset name(s) for preventive enforcement dialog copy. */
+function uniqueRulesetLabelsFromViolations(appliedViolations) {
+    const rulesetNames = [
+        ...new Set(appliedViolations
+            .map((v) => v.ruleset_name?.trim() || v.finding_title?.trim() || '')
+            .filter(Boolean)),
+    ];
+    return rulesetNames.length > 0 ? rulesetNames.join('\n\n') : 'Agent security policy';
+}
+function formatPreventiveAutofixDialog(appliedViolations, applyLine) {
+    const changePreview = formatRemediationChangePreviewForApplied(appliedViolations);
+    const changePreviewBlock = changePreview ? `${changePreview}\n\n` : '';
+    return ('Optimus Labs enforced a preventive agent security policy as determined by your security team:\n\n' +
+        `${uniqueRulesetLabelsFromViolations(appliedViolations)}\n\n` +
+        changePreviewBlock +
+        `${applyLine}\n\n` +
+        'Click OK to continue');
+}
+/** Claude dialog after enforced/preventive remediation is applied locally. */
+export function formatClaudeAutofixDialog(appliedViolations) {
+    return formatPreventiveAutofixDialog(appliedViolations, 'Claude will now apply this policy to your environment.');
+}
+/** Copilot dialog after enforced/preventive remediation is applied locally (no restart). */
+export function formatCopilotAutofixDialog(appliedViolations) {
+    return formatPreventiveAutofixDialog(appliedViolations, 'Copilot will now apply this policy to your environment.');
+}
+/** OpenCode dialog after enforced/preventive remediation is applied locally (terminal, no restart). */
+export function formatOpenCodeAutofixDialog(appliedViolations) {
+    return formatPreventiveAutofixDialog(appliedViolations, 'OpenCode will now apply this policy to your environment.');
+}
+/** Cursor restart after local autofix (all JSON settings + vscdb paths use restart_commands). */
+export function formatCursorRestartAutofixDialog(appliedViolations) {
+    return formatPreventiveAutofixDialog(appliedViolations, 'Cursor will restart so the running app reloads policy from disk. Your context will be retained.');
+}
+/**
+ * Upload a secondary compliance file to the backend so the server can resolve the finding.
+ * Fire-and-forget: upload runs in background; any failure is logged but does not block the gate.
+ */
+async function _uploadSecondaryFile(entry) {
+    const { uuid, config_file_path, file_type } = entry;
+    const uploadFileType = resolveRemediationUploadFileType(config_file_path, file_type ?? undefined);
+    if (!uploadFileType) {
+        hookRunLog(`secondary_upload: skipping uuid=${uuid} — no file_type on secondary group`);
+        return;
+    }
+    const diskPath = resolveRemediationConfigPath(config_file_path);
+    let rawContent;
+    try {
+        const parsed = parseJsonWithJsoncFallback(readFileSync(diskPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            hookRunLog(`secondary_upload: invalid JSON uuid=${uuid} path=${diskPath}`);
+            return;
+        }
+        rawContent = parsed;
+    }
+    catch {
+        hookRunLog(`secondary_upload: could not read file uuid=${uuid} path=${diskPath}`);
+        return;
+    }
+    const hw = tryResolveHardwareUuid();
+    if (!hw) {
+        hookRunLog(`secondary_upload: hardware UUID unavailable, skipping uuid=${uuid}`);
+        return;
+    }
+    const portablePath = config_file_path.includes('Cursor/User/settings.json')
+        ? PORTABLE_CURSOR_USER_SETTINGS
+        : config_file_path.trim() || diskPath;
+    try {
+        const authKey = await ensureAuthentication(hw);
+        const sent = await sendConfigFile({ file_type: uploadFileType, file_path: portablePath, raw_content: rawContent }, hw, authKey);
+        hookRunLog(`secondary_upload: uuid=${uuid} path=${portablePath} sent=${sent}`);
+    }
+    catch (err) {
+        hookRunLog(`secondary_upload: upload failed uuid=${uuid} path=${portablePath} err=${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Entry when the default npm bin (`log-llm-config` / cli.js) dispatches
+ * `compliance_prompt_gate` — npx does not execute compliance_prompt_gate.js as argv[1], so
+ * {@link isRunAsCliModule} is false and the gate must be invoked explicitly from cli.ts.
+ */
+export async function runCompliancePromptGateCli() {
+    getStoryId();
+    try {
+        await runCompliancePromptGate();
+        // Gate blocks prompt submit — buffer telemetry (no inline POST); the background runner flushes it.
+        bufferFunctionalRun({ unit: 'compliance', command: 'compliance_prompt_gate', outcome: 'ok' });
+    }
+    catch (err) {
+        bufferFunctionalRun({
+            unit: 'compliance',
+            command: 'compliance_prompt_gate',
+            outcome: 'failed',
+            message: err instanceof Error ? `${err.name}: ${err.message}` : String(err),
+            detail: err instanceof Error && err.stack ? err.stack : String(err),
+        });
+        printAllow(parseIde());
+    }
+}
+/** Exported for tests; runs when `dist/compliance_prompt_gate.js` is the process entry (argv[1]). */
+export async function runCompliancePromptGate() {
+    const ide = parseIde();
+    const agent = parseAgent(ide);
+    let complianceLogPath = parseComplianceLogArg(process.argv);
+    if (complianceLogPath) {
+        complianceLogPath = initComplianceSessionForGate(complianceLogPath);
+    }
+    else {
+        hookLogSessionBanner('compliance_prompt_gate (before submit)');
+    }
+    let status = runLocalRemediationComplianceCheck(agent);
+    const postRestartVerify = reportPostRestartVerificationOutcomes(status.violations);
+    if (postRestartVerify.outcomes.length > 0) {
+        await Promise.allSettled(postRestartVerify.reportPromises);
+        await flushRemediationOutcomeToServer(complianceLogPath);
+        hookRunLog(`compliance_prompt_gate: post_restart_verification count=${postRestartVerify.outcomes.length} quarantined=${postRestartVerify.outcomes.filter((o) => o.status === 'quarantined').length}`);
+        status = runLocalRemediationComplianceCheck(agent);
+    }
+    const hw = tryResolveHardwareUuid();
+    if (hw) {
+        try {
+            await Promise.race([
+                syncRemediations(loadEndpointBase(), hw),
+                new Promise((resolve) => setTimeout(resolve, 3000)),
+            ]);
+        }
+        catch {
+            // Network or auth failure — fall back to local file state.
+        }
+    }
+    status = runLocalRemediationComplianceCheck(agent);
+    // Secondary-satisfied: primary checks failed but settings.json (or equiv) has the fix.
+    // Upload those files fire-and-forget so the backend can resolve the finding immediately.
+    for (const e of status.secondarySatisfied ?? []) {
+        _uploadSecondaryFile(e).catch(() => undefined);
+    }
+    if (status.status === 'fail' && status.violations.length > 0) {
+        const staleMs = getManifestStalenessMs();
+        if (staleMs !== null && staleMs > MANIFEST_STALE_MS) {
+            const staleDays = Math.floor(staleMs / (24 * 60 * 60 * 1000));
+            const advisory = `Remediation enforcement suspended: local remediation manifest is stale (${staleDays} days old). ` +
+                'Please reconnect to sync latest policy state.';
+            logRemediationApplyFailure('prompt_gate_stale_manifest_advisory', {
+                reason: advisory,
+                stale_days: staleDays,
+                violation_count: status.violations.length,
+            });
+            printAllowWithAdvisory(ide, advisory);
+            return;
+        }
+        const actionableViolations = status.violations.filter((v) => !isRemediationQuarantined(v.uuid));
+        if (actionableViolations.length === 0 && status.violations.length > 0) {
+            hookRunLog(`compliance_prompt_gate: all ${status.violations.length} violation(s) quarantined — allowing prompt silently (backend notified on quarantine)`);
+            logRemediationApplyFailure('prompt_gate_quarantined_silent_allow', {
+                reason: 'all violations quarantined; no dialog — enforcement paused on this machine',
+                quarantined_count: status.violations.length,
+            });
+            printAllow(ide);
+            return;
+        }
+        const { fixed, appliedViolations = [], restartCommands, failedViolations, reportPromises, deferredSqlitePending, } = applyAutofixViolations(actionableViolations, agent);
+        hookRunLog(`compliance_prompt_gate: autofix result ide=${ide} fixed=${fixed} applied=${appliedViolations.length} failed=${failedViolations.length} restart_commands=${restartCommands.length} deferred_sqlite_pending=${deferredSqlitePending}`);
+        if (fixed > 0) {
+            // Wait for all server reports before exiting so the POST lands.
+            await Promise.allSettled(reportPromises);
+            // Deferred SQLite can leave recheck failing until restart; that must not hide a separate
+            // failed autofix (e.g. JSON remediation failed while vscdb was only queued).
+            if (failedViolations.length > 0) {
+                const ids = failedViolations.map((v) => `[${v.finding_formatted_id}]`).join(', ');
+                const msg = `Auto-fix failed for ${ids} — please fix manually or contact your security team.\n\n${failedViolations[0]?.message ?? ''}`;
+                logRemediationApplyFailure('prompt_gate_block_autofix_failed', {
+                    reason: 'autofix had fixed>0 path but failedViolations non-empty after apply',
+                    ide,
+                    failed_formatted_ids: failedViolations.map((v) => v.finding_formatted_id).join(', '),
+                    detail: failedViolations[0]?.message ?? '',
+                });
+                console.log(blockPayload(ide, msg));
+                return;
+            }
+            const recheck = runLocalRemediationComplianceCheck(agent);
+            const recheckOk = recheck.status === 'ok' || recheck.violations.length === 0;
+            // Cursor: tolerate a failing recheck only when SQLite updates are deferred (apply after restart).
+            // Claude / Copilot: JSON remediations are written immediately; merge/verify timing can still leave
+            // the in-process recheck red for the same UUID — allow in that case for immediate JSON agents.
+            const appliedUuids = new Set(appliedViolations.map((v) => v.uuid));
+            const claudeRecheckStaleAfterImmediateApply = (ide === 'claude' || ide === 'copilot' || ide === 'opencode') &&
+                !recheckOk &&
+                recheck.violations.length > 0 &&
+                recheck.violations.every((v) => appliedUuids.has(v.uuid));
+            if (claudeRecheckStaleAfterImmediateApply) {
+                hookRunLog(`compliance_prompt_gate: ${ide} — autofix wrote JSON; recheck still flags same UUID(s) — proceeding (immediate apply)`);
+            }
+            if (deferredSqlitePending || recheckOk || claudeRecheckStaleAfterImmediateApply) {
+                // Immediate-JSON agents (Claude / Claude Desktop, Copilot, OpenCode) write the config file to
+                // disk synchronously; a restart_command, if present, only reloads the already-compliant file
+                // into the running app — it is not the mechanism that makes the fix take effect. So report
+                // "verified" now instead of leaving the finding "pending" in the UI until the next prompt.
+                // Cursor JSON: disk recheck OK → verified before restart. Cursor deferred vscdb → verify after restart.
+                const immediateJsonAgent = ide === 'claude' || ide === 'copilot' || ide === 'opencode';
+                const diskProvenCompliant = recheckOk || claudeRecheckStaleAfterImmediateApply;
+                const cursorRestartVerifyPending = cursorAutofixDefersInlineVerify(ide, restartCommands.length, deferredSqlitePending === true, diskProvenCompliant);
+                const immediateVerified = !deferredSqlitePending &&
+                    !cursorRestartVerifyPending &&
+                    diskProvenCompliant &&
+                    (restartCommands.length === 0 || immediateJsonAgent || ide === 'cursor');
+                if (immediateVerified) {
+                    confirmAppliedAutofixVerified(appliedViolations, reportPromises);
+                    await Promise.allSettled(reportPromises);
+                    await flushRemediationOutcomeToServer(complianceLogPath);
+                }
+                const changePreview = formatRemediationChangePreviewForApplied(appliedViolations);
+                const changePreviewSuffix = changePreview ? `\n\n${changePreview}` : '';
+                const autofixMessage = ide === 'cursor' && restartCommands.length > 0
+                    ? formatCursorRestartAutofixDialog(appliedViolations)
+                    : ide === 'claude'
+                        ? formatClaudeAutofixDialog(appliedViolations)
+                        : ide === 'copilot'
+                            ? formatCopilotAutofixDialog(appliedViolations)
+                            : ide === 'opencode'
+                                ? formatOpenCodeAutofixDialog(appliedViolations)
+                                : `Optimus Labs auto-fixed ${fixed} ${fixed === 1 ? 'ruleset violation' : 'ruleset violations'}:\n\n${appliedViolations
+                                    .map((v) => autofixDialogLine(v))
+                                    .join('\n')}${changePreviewSuffix}`;
+                const payload = { __optimus_autofix: true, autofix_message: autofixMessage };
+                if (restartCommands.length > 0)
+                    payload.restart_commands = restartCommands;
+                console.log(JSON.stringify(payload));
+                // Restarts: always executed by optimus-compliance-check.sh via execute_trusted_restarts (TS allowlist + spawn).
+                return;
+            }
+            const msg = recheck.violations[0]?.message ?? 'A security ruleset violation has been detected.';
+            logRemediationApplyFailure('prompt_gate_block_recheck_failed', {
+                reason: 'after autofix, local compliance recheck still reports violations',
+                ide,
+                deferred_sqlite_pending: deferredSqlitePending,
+                first_uuid: recheck.violations[0]?.uuid ?? '',
+                message: msg,
+            });
+            console.log(blockPayload(ide, msg));
+            return;
+        }
+        if (failedViolations.length > 0) {
+            const ids = failedViolations.map((v) => `[${v.finding_formatted_id}]`).join(', ');
+            const msg = `Auto-fix failed for ${ids} — please fix manually or contact your security team.\n\n${failedViolations[0]?.message ?? ''}`;
+            logRemediationApplyFailure('prompt_gate_block_autofix_failed', {
+                reason: 'autofix failed (fixed=0 branch or partial failure)',
+                ide,
+                failed_formatted_ids: failedViolations.map((v) => v.finding_formatted_id).join(', '),
+                detail: failedViolations[0]?.message ?? '',
+            });
+            console.log(blockPayload(ide, msg));
+            return;
+        }
+        const msg = status.violations[0]?.message ?? 'A security ruleset violation has been detected.';
+        logRemediationApplyFailure('prompt_gate_block_violations_no_autofix_applied', {
+            reason: 'violations on submit but autofix did not succeed — see autofix_skipped_not_allowed, enforceRemediation, or compliance_check entries',
+            ide,
+            first_uuid: status.violations[0]?.uuid ?? '',
+            finding_formatted_id: status.violations[0]?.finding_formatted_id ?? '',
+        });
+        console.log(blockPayload(ide, msg));
+        return;
+    }
+    // No violations: clean up satisfied one-time remediations so they don't linger locally forever.
+    const pruned = pruneSatisfiedOneTimeRemediations(agent);
+    if (pruned.removed > 0) {
+        await Promise.allSettled(pruned.reportPromises);
+    }
+    await Promise.allSettled(uploadSatisfiedManifestConfigs(agent));
+    await Promise.allSettled(reportCompliantRemediationVerifiedStatus(agent));
+    printAllow(ide);
+}
+if (isRunAsCliModule()) {
+    runCompliancePromptGateCli().finally(() => process.exit(0));
+}

package/dist/dialog_prefs_cli.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * CLI for macOS non-restart autofix dialogs and dialog preferences in ~/.optimuslabs/management.
+ * Invoked from optimus-compliance-check.sh hooks.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { isNonRestartAutofixDialogSuppressed, setSuppressNonRestartAutofixDialogs, } from './log_config_files/runtime/dialog_preferences.js';
+export const STOP_NOTIFICATIONS_BUTTON = 'Mute Alerts';
+export const OK_BUTTON = 'OK';
+function cliParts() {
+    const a = process.argv;
+    if (a[2] === 'dialog_prefs')
+        return a.slice(2);
+    // Invoked as npm bin `dialog_prefs-staging` / `dialog_prefs` (argv[2] is the subcommand).
+    if (a[2] === 'is_suppressed' || a[2] === 'set_suppress' || a[2] === 'show') {
+        return ['dialog_prefs', a[2], ...a.slice(3)];
+    }
+    return a.slice(2);
+}
+function parseArgValue(parts, flag) {
+    const eq = parts.find((p) => p.startsWith(`${flag}=`));
+    if (eq)
+        return eq.slice(flag.length + 1);
+    const idx = parts.indexOf(flag);
+    if (idx >= 0 && parts[idx + 1])
+        return parts[idx + 1];
+    return undefined;
+}
+function escapeAppleScriptString(text) {
+    return text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function icnsIconClause() {
+    const p = (process.env.OPTIMUS_DIALOG_ICNS ?? '').trim();
+    if (!p || !existsSync(p))
+        return 'with icon caution';
+    try {
+        const buf = readFileSync(p);
+        if (buf.length < 8 || buf.subarray(0, 4).toString('ascii') !== 'icns') {
+            return 'with icon caution';
+        }
+    }
+    catch {
+        return 'with icon caution';
+    }
+    return `with icon POSIX file "${escapeAppleScriptString(p)}"`;
+}
+export function buildNonRestartAutofixDialogScript(message, target) {
+    const msg = escapeAppleScriptString(message);
+    const icon = icnsIconClause();
+    const mute = escapeAppleScriptString(STOP_NOTIFICATIONS_BUTTON);
+    const body = `display dialog "${msg}" with title "Optimus Labs" buttons {"${mute}", "${OK_BUTTON}"} default button "${OK_BUTTON}" ${icon}`;
+    if (target === 'cursor') {
+        return `tell application "Cursor" to ${body}`;
+    }
+    if (target === 'claude-app') {
+        return `tell application "Claude" to ${body}`;
+    }
+    return body;
+}
+export function showNonRestartAutofixDialog(message, target) {
+    const script = buildNonRestartAutofixDialogScript(message, target);
+    let out = '';
+    try {
+        out = execFileSync('osascript', ['-'], { input: script, encoding: 'utf8' });
+    }
+    catch (err) {
+        const e = err;
+        out = typeof e.stdout === 'string' ? e.stdout : '';
+        // User dismissed or osascript failed — do not block callers; preference only set on explicit Stop.
+        if (!out.includes(STOP_NOTIFICATIONS_BUTTON)) {
+            throw err;
+        }
+    }
+    if (out.includes(STOP_NOTIFICATIONS_BUTTON)) {
+        setSuppressNonRestartAutofixDialogs(true);
+        return 'stop_notifications';
+    }
+    return 'ok';
+}
+function readMessageFile(path) {
+    if (!path || !existsSync(path)) {
+        throw new Error(`message file not found: ${path}`);
+    }
+    return readFileSync(path, 'utf8');
+}
+export async function runDialogPrefsCli() {
+    const parts = cliParts();
+    const sub = parts[1];
+    if (sub === 'is_suppressed') {
+        console.log(isNonRestartAutofixDialogSuppressed() ? 'true' : 'false');
+        return;
+    }
+    if (sub === 'set_suppress') {
+        setSuppressNonRestartAutofixDialogs(true);
+        return;
+    }
+    if (sub === 'show') {
+        const messageFile = parseArgValue(parts, '--message-file');
+        const targetRaw = parseArgValue(parts, '--target') ?? 'terminal';
+        if (targetRaw !== 'cursor' && targetRaw !== 'claude-app' && targetRaw !== 'terminal') {
+            throw new Error(`invalid --target: ${targetRaw}`);
+        }
+        const message = readMessageFile(messageFile ?? '');
+        showNonRestartAutofixDialog(message, targetRaw);
+        return;
+    }
+    throw new Error(`unknown dialog_prefs subcommand: ${sub ?? '(none)'}`);
+}

package/dist/endpoint_client/compress_payload.js

@@ -0,0 +1,25 @@
+import { spawnSync } from 'node:child_process';
+/** macOS ships gzip at a fixed path; call it directly so a modified PATH cannot redirect us. */
+const GZIP_BIN = '/usr/bin/gzip';
+const GZIP_TIMEOUT_MS = 10_000;
+const GZIP_MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+/**
+ * Compress a request body with the system gzip. Output is gzip-framed, so it pairs with
+ * `Content-Encoding: gzip`. Throws if gzip is missing, times out, or exits non-zero.
+ */
+export function gzipPayload(payload) {
+    const child = spawnSync(GZIP_BIN, ['-c'], {
+        input: Buffer.from(payload, 'utf8'),
+        timeout: GZIP_TIMEOUT_MS,
+        maxBuffer: GZIP_MAX_OUTPUT_BYTES,
+    });
+    if (child.error)
+        throw child.error;
+    if (child.status !== 0) {
+        const stderr = (child.stderr ?? '').toString().trim();
+        throw new Error(stderr || `${GZIP_BIN} exited ${child.status ?? 'unknown'}`);
+    }
+    if (!child.stdout || child.stdout.length === 0)
+        throw new Error(`${GZIP_BIN} produced no output`);
+    return child.stdout;
+}

package/dist/endpoint_client/http_transport.js

@@ -0,0 +1,90 @@
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+/** Normalize localhost/::1 to 127.0.0.1 to avoid IPv6 resolution issues. */
+function resolveHostname(raw) {
+    return raw === 'localhost' || raw === '::1' ? '127.0.0.1' : raw;
+}
+function buildGetOptions(url, timeoutMs) {
+    const isHttps = url.protocol === 'https:';
+    return {
+        hostname: resolveHostname(url.hostname),
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname + url.search,
+        method: 'GET',
+        timeout: timeoutMs,
+    };
+}
+function buildBodyOptions(url, payload, method, timeoutMs) {
+    const isHttps = url.protocol === 'https:';
+    return {
+        hostname: resolveHostname(url.hostname),
+        port: url.port || (isHttps ? 443 : 80),
+        path: `${url.pathname}${url.search}`,
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(payload).toString(),
+            // A Buffer body is always gzip output from compress_payload.gzipPayload.
+            ...(Buffer.isBuffer(payload) ? { 'Content-Encoding': 'gzip' } : {}),
+        },
+        timeout: timeoutMs,
+    };
+}
+/** Execute a GET request. Returns statusCode=0 and empty body on network/timeout failure. */
+export function executeGet(urlStr, timeoutMs) {
+    const url = new URL(urlStr);
+    const options = buildGetOptions(url, timeoutMs);
+    const transport = url.protocol === 'https:' ? https.request : http.request;
+    return new Promise((resolve) => {
+        const req = transport(options, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => resolve({ statusCode: res.statusCode ?? 0, body }));
+        });
+        req.on('error', () => resolve({ statusCode: 0, body: '' }));
+        req.on('timeout', () => { req.destroy(); resolve({ statusCode: 0, body: '' }); });
+        req.end();
+    });
+}
+/** Execute a POST/PATCH request. A Buffer payload is sent as `Content-Encoding: gzip`. Rejects on network error or timeout. */
+export function executeBody(urlStr, method, payload, timeoutMs) {
+    const url = new URL(urlStr);
+    const options = buildBodyOptions(url, payload, method, timeoutMs);
+    const transport = url.protocol === 'https:' ? https.request : http.request;
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const timer = setTimeout(() => {
+            if (!done) {
+                done = true;
+                req.destroy();
+                reject(new Error(`Request timeout after ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+        const req = transport(options, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                done = true;
+                clearTimeout(timer);
+                resolve({ statusCode: res.statusCode ?? 0, statusMessage: res.statusMessage ?? '', headers: res.headers, body });
+            });
+        });
+        req.on('error', (err) => {
+            done = true;
+            clearTimeout(timer);
+            console.error('Request error:', err.message, err.code);
+            reject(err);
+        });
+        req.on('timeout', () => {
+            done = true;
+            clearTimeout(timer);
+            req.destroy();
+            reject(new Error(`Request timeout after ${timeoutMs}ms`));
+        });
+        req.write(payload);
+        req.end();
+    });
+}

package/dist/endpoint_client/index.js

@@ -0,0 +1,3 @@
+export { FILE_PATH_REGISTRY_FILE_PATTERNS_PATH, FILE_PATH_REGISTRY_SENSITIVE_PATHS_PATH, } from './types.js';
+export { buildApiUrl, getFileCollectionPatterns, getSensitivePathsAuditCandidates, } from './registry_api.js';
+export { postStartupPayload, patchPayload, classifyEndpointResponse } from './startup_api.js';

package/dist/endpoint_client/registry_api.js

@@ -0,0 +1,41 @@
+import { URL } from 'node:url';
+import { executeGet } from './http_transport.js';
+import { FILE_PATH_REGISTRY_FILE_PATTERNS_PATH, FILE_PATH_REGISTRY_SENSITIVE_PATHS_PATH, } from './types.js';
+/** Join API base (may include a path prefix, e.g. https://host/optimus/) with an absolute API path. */
+export function buildApiUrl(base, path) {
+    const normalizedBase = `${base.replace(/\/+$/, '')}/`;
+    const relativePath = path.replace(/^\/+/, '');
+    return new URL(relativePath, normalizedBase).href;
+}
+/**
+ * GET file collection patterns from the backend (what to look for).
+ * No auth required. Returns the complete list of path + type + file_type.
+ */
+export const getFileCollectionPatterns = async (apiBaseUrl, timeoutMs = 5000) => {
+    const { statusCode, body } = await executeGet(buildApiUrl(apiBaseUrl, FILE_PATH_REGISTRY_FILE_PATTERNS_PATH), timeoutMs);
+    if (statusCode !== 200 || !body)
+        return null;
+    try {
+        const parsed = JSON.parse(body);
+        return Array.isArray(parsed.patterns) && typeof parsed.count === 'number' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * GET sensitive path audit candidates from the backend (concrete paths to check for existence).
+ * No auth required. Returns path templates (~ = home). Client checks existence only, never sends contents.
+ */
+export const getSensitivePathsAuditCandidates = async (apiBaseUrl, timeoutMs = 5000) => {
+    const { statusCode, body } = await executeGet(buildApiUrl(apiBaseUrl, FILE_PATH_REGISTRY_SENSITIVE_PATHS_PATH), timeoutMs);
+    if (statusCode !== 200 || !body)
+        return null;
+    try {
+        const parsed = JSON.parse(body);
+        return Array.isArray(parsed.paths) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};