@optimuslabs/harness-map-staging 1.5.16

package/dist/log_uuid/startup_sender.js

@@ -0,0 +1,131 @@
+import { createSignature as createSharedSignature } from '../tofu.js';
+import { classifyEndpointResponse, postStartupPayload } from '../endpoint_client/index.js';
+import { flushBufferedClientEvents, getStoryId, reportFunctionalFailureAwait, reportFunctionalRun, } from '../log_config_files/runtime/client_event_reporter.js';
+import { resolveHardwareUuid } from './hardware_uuid.js';
+import { writeAuthKey, readStoredAuthKey, loadEndpointBase, buildStartupEndpointUrl } from './auth_key_store.js';
+import { resolveUserProfile } from './user_profile.js';
+import { resolveWorkspaceRepo } from '../log_config_files/runtime/workspace_repo.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const canonicalizeValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(canonicalizeValue);
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const key of Object.keys(value).sort())
+            result[key] = canonicalizeValue(value[key]);
+        return result;
+    }
+    return value;
+};
+const canonicalStringify = (value) => JSON.stringify(canonicalizeValue(value));
+const createSignature = (payloadSummary, keyHex) => {
+    // Keep this adapter for backward compatibility of public exports in log_uuid.
+    return createSharedSignature(payloadSummary, keyHex);
+};
+const readOrganizationUuid = () => {
+    const envValue = (process.env.OPTIMUS_ORGANIZATION_UUID || '').trim();
+    if (envValue)
+        return envValue;
+    try {
+        return fs.readFileSync(path.join(os.homedir(), '.optimuslabs', 'management', 'org', 'organization-uuid.txt'), 'utf8').trim();
+    }
+    catch {
+        return '';
+    }
+};
+const parseHookManifest = () => {
+    const raw = (process.env.OPTIMUS_HOOK_MANIFEST || '').trim();
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // malformed — skip
+    }
+    return {};
+};
+const getMetadata = () => ({
+    github_username: process.env.GITHUB_USER || process.env.GH_USER || '',
+    org_identifier: process.env.GITHUB_ORG || '',
+    organization_uuid: readOrganizationUuid(),
+    repo_identifier: resolveWorkspaceRepo(),
+    branch: process.env.GITHUB_REF_NAME || process.env.BRANCH_NAME || '',
+    commit_sha: process.env.GITHUB_SHA || '',
+    agent_name: process.env.OPTIMUS_AGENT || '',
+    user_profile: { ...resolveUserProfile() },
+    hook_manifest: parseHookManifest(),
+});
+function buildRequestBody(hardwareUuid, timestamp) {
+    const payloadSummary = { timestamp, directory: process.cwd(), hardware_uuid: hardwareUuid };
+    const requestBody = { hardware_uuid: hardwareUuid, payload: payloadSummary, metadata: getMetadata(), scan_timestamp: timestamp };
+    const storedKey = readStoredAuthKey();
+    if (storedKey?.key && storedKey.hardware_uuid === hardwareUuid) {
+        requestBody.signature = createSignature(payloadSummary, storedKey.key);
+        if (storedKey.key_id)
+            requestBody.key_id = storedKey.key_id;
+        console.log('Using stored auth key to sign startup payload.');
+    }
+    else if (storedKey && storedKey.hardware_uuid !== hardwareUuid) {
+        console.warn('Stored auth key hardware UUID mismatch; requesting new key from server.');
+    }
+    else {
+        console.log('No stored auth key found; requesting new key from server.');
+    }
+    return requestBody;
+}
+const maybeSendToEndpoint = async (hardwareUuid, timestamp, options = {}) => {
+    const startupEndpointUrl = buildStartupEndpointUrl(loadEndpointBase());
+    const requestBody = buildRequestBody(hardwareUuid, timestamp);
+    try {
+        const response = await postStartupPayload(startupEndpointUrl, requestBody);
+        const result = classifyEndpointResponse(response);
+        console.log(result.message);
+        if (result.branch === 'key_issued' && result.key) {
+            writeAuthKey(result.key, result.keyId, hardwareUuid);
+            const manifest = parseHookManifest();
+            if (options.allowKeyIssuedRetry !== false &&
+                Object.keys(manifest).length > 0) {
+                return maybeSendToEndpoint(hardwareUuid, new Date().toISOString(), {
+                    allowKeyIssuedRetry: false,
+                });
+            }
+        }
+        return result.branch !== 'error';
+    }
+    catch (error) {
+        console.error(`Failed to contact endpoint: ${error.message}`);
+        return false;
+    }
+};
+const main = async () => {
+    getStoryId();
+    void flushBufferedClientEvents();
+    const timestamp = new Date().toISOString();
+    try {
+        const hardwareUuid = resolveHardwareUuid();
+        const ok = await maybeSendToEndpoint(hardwareUuid, timestamp);
+        if (ok) {
+            await reportFunctionalRun({
+                unit: 'auth_version',
+                command: 'log_uuid',
+                outcome: 'ok',
+                hook_name: 'start_every_prompt',
+            });
+        }
+        else {
+            await reportFunctionalFailureAwait('auth_version', 'log_uuid', new Error('startup payload request failed'));
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        await reportFunctionalFailureAwait('auth_version', 'log_uuid', error instanceof Error ? error : new Error(String(error)));
+        console.error(`Unable to log hardware UUID: ${error.message}`);
+        process.exitCode = 1;
+    }
+};
+export { canonicalizeValue, canonicalStringify, createSignature, getMetadata, maybeSendToEndpoint, main };

package/dist/log_uuid/user_profile.js

@@ -0,0 +1,192 @@
+import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readCommandOutput, resolveHardwareUuid } from './hardware_uuid.js';
+const safeJsonParse = (raw) => {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+const readCursorCachedEmailFromVscdb = () => {
+    const dbPath = path.join(os.homedir(), 'Library/Application Support/Cursor/User/globalStorage/state.vscdb');
+    if (!fs.existsSync(dbPath))
+        return '';
+    try {
+        const out = execFileSync('sqlite3', [dbPath, "select value from ItemTable where key='cursorAuth/cachedEmail';"], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return out;
+    }
+    catch {
+        return '';
+    }
+};
+/** Fallback: `storage.json` key path `cursor.auth.email` (design_notes). */
+const readCursorCachedEmailFromStorageJson = () => {
+    const fp = path.join(os.homedir(), 'Library/Application Support/Cursor/User/globalStorage/storage.json');
+    if (!fs.existsSync(fp))
+        return '';
+    try {
+        const parsed = safeJsonParse(fs.readFileSync(fp, { encoding: 'utf8' }));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return '';
+        const root = parsed;
+        const cursor = root.cursor;
+        if (!cursor || typeof cursor !== 'object' || Array.isArray(cursor))
+            return '';
+        const auth = cursor.auth;
+        if (!auth || typeof auth !== 'object' || Array.isArray(auth))
+            return '';
+        const email = auth.email;
+        return typeof email === 'string' ? email.trim() : '';
+    }
+    catch {
+        return '';
+    }
+};
+const readCursorCachedEmail = () => readCursorCachedEmailFromVscdb() || readCursorCachedEmailFromStorageJson();
+const readClaudeAuthEmailFromCli = () => {
+    try {
+        const out = execFileSync('claude', ['auth', 'status'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (!out)
+            return '';
+        const parsed = safeJsonParse(out);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const email = parsed.email;
+            return typeof email === 'string' ? email.trim() : '';
+        }
+    }
+    catch {
+        return '';
+    }
+    return '';
+};
+/** Fallback: optional Claude config files under ~/.claude/ (design_notes). */
+const readClaudeEmailFromHomeFiles = () => {
+    const candidates = [
+        path.join(os.homedir(), '.claude/.credentials.json'),
+        path.join(os.homedir(), '.claude/.claude.json'),
+    ];
+    for (const fp of candidates) {
+        if (!fs.existsSync(fp))
+            continue;
+        try {
+            const parsed = safeJsonParse(fs.readFileSync(fp, { encoding: 'utf8' }));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                continue;
+            const email = parsed.email;
+            if (typeof email === 'string' && email.includes('@'))
+                return email.trim();
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return '';
+};
+const readClaudeAuthEmail = () => readClaudeAuthEmailFromCli().trim() || readClaudeEmailFromHomeFiles();
+const readMachineName = () => {
+    const fromEnv = process.env.OPTIMUS_MACHINE_NAME?.trim();
+    if (fromEnv)
+        return fromEnv;
+    // macOS: human-readable computer name set in System Settings
+    if (process.platform === 'darwin') {
+        const name = readCommandOutput('scutil --get ComputerName');
+        if (name)
+            return name;
+    }
+    // Fallback: OS hostname
+    return os.hostname();
+};
+const readMacUsername = () => {
+    const fromEnv = process.env.OPTIMUS_MAC_USERNAME?.trim() ||
+        process.env.USER?.trim() ||
+        process.env.LOGNAME?.trim() ||
+        '';
+    if (fromEnv)
+        return fromEnv;
+    return readCommandOutput('id -un');
+};
+/**
+ * Matches design_notes order: `gh api user` (login), then CI-style env, then `git config user.name`.
+ * `metadata.github_username` in startup_sender still uses env only; this field is the richer probe.
+ */
+const readGithubUsername = () => {
+    try {
+        const out = execFileSync('gh', ['api', 'user', '--jq', '.login'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: 1024 * 1024,
+            // CI often has `gh` installed; without a cap it can block on auth/network and hang callers.
+            timeout: 3500,
+        }).trim();
+        if (out)
+            return out;
+    }
+    catch {
+        /* gh missing or not authenticated */
+    }
+    return (process.env.GITHUB_USER?.trim() ||
+        process.env.GH_USER?.trim() ||
+        readCommandOutput('git config user.name'));
+};
+const readUserProfileFromEnvOrFile = () => {
+    const inline = process.env.OPTIMUS_USER_PROFILE_JSON?.trim();
+    if (inline) {
+        const parsed = safeJsonParse(inline);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    const filePath = process.env.OPTIMUS_USER_PROFILE_FILE?.trim();
+    if (filePath && fs.existsSync(filePath)) {
+        const parsed = safeJsonParse(fs.readFileSync(filePath, { encoding: 'utf8' }));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    return null;
+};
+const isPlausibleUuid = (s) => /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(s.trim());
+/**
+ * macOS Open Directory **GeneratedUID** for the console user (same concept as Directory Utility).
+ * See `dscl . -read /Users/<shortname> GeneratedUID`. Not the hardware UUID (that is `machineuuid`).
+ *
+ * `OPTIMUS_MAC_GENERATED_UID` overrides for tests or locked-down environments where `dscl` is unavailable.
+ */
+const readMacAccountGeneratedUid = () => {
+    const env = process.env.OPTIMUS_MAC_GENERATED_UID?.trim();
+    if (env && isPlausibleUuid(env))
+        return env.trim().toLowerCase();
+    if (process.platform !== 'darwin')
+        return '';
+    const user = readMacUsername();
+    if (!user || !/^[a-zA-Z0-9._-]+$/.test(user))
+        return '';
+    try {
+        const out = execFileSync('dscl', ['.', '-read', `/Users/${user}`, 'GeneratedUID'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const m = out.match(/GeneratedUID:\s*([0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12})/);
+        if (m?.[1] && isPlausibleUuid(m[1]))
+            return m[1].toLowerCase();
+    }
+    catch {
+        return '';
+    }
+    return '';
+};
+const buildDefaultUserProfile = () => ({
+    generateduuid: readMacAccountGeneratedUid() || crypto.randomUUID(),
+    machineuuid: resolveHardwareUuid(),
+    mac_username: readMacUsername(),
+    machine_name: readMachineName(),
+    github_username: readGithubUsername(),
+    claude_email: readClaudeAuthEmail(),
+    cursor_email: readCursorCachedEmail(),
+});
+/** Best-effort local user profile object for startup metadata. */
+const resolveUserProfile = () => readUserProfileFromEnvOrFile() ?? buildDefaultUserProfile();
+export { resolveUserProfile };

package/dist/remediation_change_preview.js

@@ -0,0 +1,182 @@
+import { readRemediationInstructionsFile } from './log_config_files/runtime/management_storage.js';
+import { remediationFixSpec } from './log_config_files/runtime/remediation_sync.js';
+export const MAX_PREVIEW_LINES = 5;
+export const MAX_PREVIEW_LINE_CHARS = 72;
+function truncateLine(text, max = MAX_PREVIEW_LINE_CHARS) {
+    const trimmed = text.trim();
+    if (trimmed.length <= max)
+        return trimmed;
+    return `${trimmed.slice(0, max - 1)}…`;
+}
+function formatScalar(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (typeof value === 'string')
+        return `"${value}"`;
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const parts = value.slice(0, 2).map((entry) => formatScalar(entry));
+        if (value.length > 2)
+            return `${parts.join(', ')} …+${value.length - 2}`;
+        return parts.join(', ');
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        if (typeof record.serverName === 'string')
+            return `"${record.serverName}"`;
+        const keys = Object.keys(record);
+        if (keys.length === 1 && keys[0])
+            return formatScalar(record[keys[0]]);
+        if (keys.length <= 3)
+            return `{${keys.join(', ')}}`;
+        return `{${keys.slice(0, 2).join(', ')}, …}`;
+    }
+    return String(value);
+}
+function formatListDeltaItems(items) {
+    if (items.length === 0)
+        return '—';
+    const shown = items.slice(0, 2).map((entry) => formatScalar(entry));
+    if (items.length > 2)
+        return `${shown.join(', ')} …+${items.length - 2}`;
+    return shown.join(', ');
+}
+function leafFromSettingPath(settingPath, opKey) {
+    const path = settingPath.trim();
+    if (!path)
+        return opKey;
+    if (path.endsWith(`.${opKey}`))
+        return opKey;
+    const last = path.split('.').pop();
+    return last && last.length > 0 ? last : opKey;
+}
+function linesFromOps(check) {
+    const lines = [];
+    const settingPath = check.setting_path ?? '';
+    const ops = check.ops;
+    if (!ops || typeof ops !== 'object')
+        return lines;
+    const setOps = ops.set;
+    if (setOps && typeof setOps === 'object') {
+        for (const [key, value] of Object.entries(setOps)) {
+            const leaf = Object.keys(setOps).length === 1 ? leafFromSettingPath(settingPath, key) : key;
+            lines.push(`Set ${leaf} → ${formatScalar(value)}`);
+        }
+    }
+    const addOps = ops.add;
+    if (addOps && typeof addOps === 'object') {
+        for (const [key, items] of Object.entries(addOps)) {
+            if (!Array.isArray(items))
+                continue;
+            lines.push(`Add to ${key}: ${formatListDeltaItems(items)}`);
+        }
+    }
+    const removeOps = ops.remove;
+    if (removeOps && typeof removeOps === 'object') {
+        for (const [key, items] of Object.entries(removeOps)) {
+            if (Array.isArray(items)) {
+                lines.push(`Remove from ${key}: ${formatListDeltaItems(items)}`);
+                continue;
+            }
+            if (items && typeof items === 'object') {
+                lines.push(`Remove from ${key}: ${formatListDeltaItems(Object.keys(items))}`);
+            }
+        }
+    }
+    return lines;
+}
+function linesFromSqliteOp(check) {
+    const sqliteOp = check.sqlite_op;
+    if (!sqliteOp || typeof sqliteOp !== 'object')
+        return [];
+    const lines = [];
+    const settingPath = check.setting_path ?? '';
+    const updates = sqliteOp.updates;
+    if (updates && typeof updates === 'object') {
+        for (const [key, value] of Object.entries(updates)) {
+            lines.push(`Set ${leafFromSettingPath(settingPath, key)} → ${formatScalar(value)}`);
+        }
+    }
+    const unionAdd = sqliteOp.array_union_add;
+    if (Array.isArray(unionAdd) && unionAdd.length > 0) {
+        const target = sqliteOp.target_key ?? 'list';
+        lines.push(`Add to ${target}: ${formatListDeltaItems(unionAdd)}`);
+    }
+    return lines;
+}
+function linesFromCheck(check) {
+    const fromOps = linesFromOps(check);
+    if (fromOps.length > 0)
+        return fromOps;
+    return linesFromSqliteOp(check);
+}
+function linesFromFixSpec(spec) {
+    if (!spec)
+        return [];
+    if (Array.isArray(spec.checks) && spec.checks.length > 0) {
+        return spec.checks.flatMap((check) => linesFromCheck(check));
+    }
+    if (spec.setting_path || spec.ops) {
+        return linesFromCheck({ setting_path: spec.setting_path, ops: spec.ops });
+    }
+    return [];
+}
+/** Basename for macOS dialog copy (vscdb paths shortened). */
+export function previewFileLabel(configFilePath) {
+    if (!configFilePath?.trim())
+        return 'config file';
+    const normalized = configFilePath.replace(/\\/g, '/');
+    const hashIdx = normalized.indexOf('#');
+    const pathPart = hashIdx >= 0 ? normalized.slice(0, hashIdx) : normalized;
+    const fragment = hashIdx >= 0 ? normalized.slice(hashIdx + 1) : '';
+    const segments = pathPart.split('/').filter(Boolean);
+    const base = segments[segments.length - 1] ?? pathPart;
+    if (base.endsWith('.vscdb') || base === 'state.vscdb') {
+        if (fragment && fragment !== 'composerState') {
+            const short = fragment.length > 28
+                ? fragment.includes('/')
+                    ? (fragment.split('/').pop() ?? fragment)
+                    : fragment
+                : fragment;
+            return `state.vscdb (${short})`;
+        }
+        return 'state.vscdb';
+    }
+    return base || 'config file';
+}
+export function collectRemediationPreviewLines(appliedViolations, remediations, maxLines = MAX_PREVIEW_LINES) {
+    const byUuid = new Map(remediations.map((row) => [row.uuid, row]));
+    const fileLabels = new Set();
+    const allLines = [];
+    for (const violation of appliedViolations) {
+        const instruction = byUuid.get(violation.uuid);
+        const spec = instruction ? remediationFixSpec(instruction) : null;
+        fileLabels.add(previewFileLabel(instruction?.config_file_path ?? violation.config_file_path ?? ''));
+        allLines.push(...linesFromFixSpec(spec));
+    }
+    const lines = allLines.slice(0, maxLines);
+    const hiddenCount = Math.max(0, allLines.length - lines.length);
+    return { fileLabels: [...fileLabels], lines, hiddenCount };
+}
+export function formatRemediationChangePreviewSection(appliedViolations, remediations) {
+    const { fileLabels, lines, hiddenCount } = collectRemediationPreviewLines(appliedViolations, remediations);
+    if (lines.length === 0)
+        return '';
+    const filePart = fileLabels.length === 1
+        ? `Changes in ${fileLabels[0]}:`
+        : `Changes in ${fileLabels.slice(0, 2).join(', ')}${fileLabels.length > 2 ? ', …' : ''}:`;
+    const body = lines.map((line) => `  • ${truncateLine(line)}`).join('\n');
+    const tail = hiddenCount > 0
+        ? `\n  … and ${hiddenCount} more change${hiddenCount === 1 ? '' : 's'}`
+        : '';
+    return `${filePart}\n${body}${tail}`;
+}
+export function formatRemediationChangePreviewForApplied(appliedViolations) {
+    const { remediations } = readRemediationInstructionsFile();
+    return formatRemediationChangePreviewSection(appliedViolations, remediations);
+}

package/dist/tofu.js

@@ -0,0 +1,22 @@
+/**
+ * Tofu shim — centralises all imports from @optimuslabs/tofu-staging.
+ *
+ * Reads ~/.optimuslabs/management/optimus_dev.env at startup:
+ *   - No file / unreadable → staging (ignores OPTIMUS_ENVIRONMENT).
+ *   - File present → environment= line in file, then OPTIMUS_ENVIRONMENT, then staging.
+ *   - environment=development + local dist present → loads sibling optimus-tofu dist
+ *   - staging / production / npx installs → published @optimuslabs/tofu-staging npm package
+ *
+ * All other source files import from this module, never directly from
+ * "@optimuslabs/tofu-staging", so the conditional lives in exactly one place.
+ */
+import path from "path";
+import { fileURLToPath } from "url";
+import { shouldUseLocalTofuDist } from "./tofu_environment.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const localTofuPath = path.join(__dirname, "../../optimus-tofu/dist/index.js");
+const useLocalTofu = shouldUseLocalTofuDist(localTofuPath);
+const tofu = (useLocalTofu
+    ? await import(localTofuPath)
+    : await import("@optimuslabs/tofu-staging"));
+export const { loadEndpointBase, normalizeBaseUrl, buildStartupEndpointUrl, createSignature, persistAuthKey, readStoredAuthKey, ensureAuthentication, getEndpointSource, canonicalizePayload, getAuthKeyPath, } = tofu;

package/dist/tofu_environment.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+export function managementEnvPath() {
+    const home = homedir();
+    if (!home)
+        return null;
+    return path.join(home, '.optimuslabs', 'management', 'optimus_dev.env');
+}
+/**
+ * Staging package: default staging when no management file (promotion rewrites to production).
+ * File present → environment= line in file, then OPTIMUS_ENVIRONMENT, then staging.
+ */
+export function readEnvironment() {
+    const envPath = managementEnvPath();
+    if (!envPath) {
+        return 'staging';
+    }
+    let content;
+    try {
+        content = readFileSync(envPath, 'utf8');
+    }
+    catch {
+        return 'staging';
+    }
+    const match = content?.match(/^(?:environment|ENVIRONMENT|OPTIMUS_ENVIRONMENT)\s*=\s*(.+)/m);
+    if (match)
+        return match[1].trim().toLowerCase();
+    const fromEnv = process.env.OPTIMUS_ENVIRONMENT?.trim().toLowerCase();
+    if (fromEnv)
+        return fromEnv;
+    return 'staging';
+}
+export function shouldUseLocalTofuDist(localTofuPath) {
+    return readEnvironment() === 'development' && existsSync(localTofuPath);
+}

package/dist/types/config_file_types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@optimuslabs/harness-map-staging",
+  "version": "1.5.16",
+  "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
+  "type": "module",
+  "bin": {
+    "log-llm-config-staging": "dist/cli.js",
+    "log_uuid-staging": "dist/log_uuid/index.js",
+    "log_config_files-staging": "dist/log_config_files/index.js",
+    "log_sensitive_paths_audit-staging": "dist/log_sensitive_paths_audit.js",
+    "apply-deferred-vscdb-staging": "dist/apply_deferred_vscdb.js",
+    "execute-trusted-restarts-staging": "dist/execute_trusted_restarts.js",
+    "compliance_prompt_gate-staging": "dist/compliance_prompt_gate.js",
+    "compliance_check_runner-staging": "dist/compliance_check_runner.js",
+    "dialog_prefs-staging": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node ../../../scripts/ensure-bin-executable.mjs",
+    "dev": "ts-node src/cli.ts",
+    "lint": "eslint \"src/**/*.ts\"",
+    "prepare": "npm run build",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "mcp",
+    "config",
+    "logging",
+    "npx"
+  ],
+  "author": "",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/optimuslabs-io/optimus-secure-fdn.git",
+    "directory": "npx_packages/staging/optimuslabs/log-llm-config"
+  },
+  "bugs": {
+    "url": "https://github.com/optimuslabs-io/optimus-secure-fdn/issues"
+  },
+  "homepage": "https://github.com/optimuslabs-io/optimus-secure-fdn/tree/main/npx_packages/staging/optimuslabs/log-llm-config#readme",
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.1.8",
+    "@vitest/ui": "^4.1.8",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5",
+    "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "axios": "^1.18.1",
+    "canonicalize": "^2.1.0",
+    "@optimuslabs/tofu-staging": "^0.1.18",
+    "smol-toml": "^1.7.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}