@optimuslabs/harness-map-staging 1.5.16

package/dist/log_config_files/readers/cursor_shadow_merge_ruleset.js

@@ -0,0 +1,46 @@
+/**
+ * Keep in sync with file_path_registry/cursor_composer_shadow_keys.py
+ * (CURSOR_REACTIVE_BLOB_SHADOW_KEYS + merge sets).
+ */
+/** Keys Cursor duplicates on the reactive blob root and inside composerState. */
+export const CURSOR_COMPOSER_SHADOW_KEYS = [
+    'lastBrowserConnectionMode',
+    'playwrightProtection',
+    'isWebSearchToolEnabled',
+    'isWebSearchToolEnabled2',
+    'isWebSearchToolEnabled3',
+    'isWebFetchToolEnabled',
+    'autoAcceptWebSearchTool',
+];
+/** Cursor Settings UI writes these on nested composerState; blob root copies are often stale. */
+export const CURSOR_SHADOW_KEYS_NESTED_WINS = new Set([
+    'playwrightProtection',
+    'isWebFetchToolEnabled',
+    'isWebSearchToolEnabled3',
+    'autoAcceptWebSearchTool',
+]);
+export function cursorShadowValueIsEnabled(value) {
+    return (value === true ||
+        value === 1 ||
+        (typeof value === 'string' && ['true', '1', 'yes'].includes(value.toLowerCase())));
+}
+/** Prefer nested when enabled (web search / auto-accept); else root. */
+export function coalesceCursorEnabledShadowValue(root, nested) {
+    if (cursorShadowValueIsEnabled(nested))
+        return nested;
+    if (cursorShadowValueIsEnabled(root))
+        return root;
+    if (root !== undefined && root !== null)
+        return root;
+    return nested;
+}
+/**
+ * After merge, ruleset scanning and uploads use composerState.<key> only — drop stale blob-root copies.
+ */
+export function stripShadowKeysFromReactiveBlobUpload(stateData) {
+    if (!('composerState' in stateData))
+        return;
+    for (const key of CURSOR_COMPOSER_SHADOW_KEYS) {
+        delete stateData[key];
+    }
+}

package/dist/log_config_files/readers/file_readers.js

@@ -0,0 +1,196 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { parse as parseToml, stringify as stringifyTomlValue } from 'smol-toml';
+function stripJsoncComments(input) {
+    let out = '';
+    let inString = false;
+    let quote = '';
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i];
+        const next = i + 1 < input.length ? input[i + 1] : '';
+        if (inLineComment) {
+            if (ch === '\n') {
+                inLineComment = false;
+                out += ch;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === quote) {
+                inString = false;
+                quote = '';
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            quote = ch;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function stripTrailingCommas(input) {
+    let out = '';
+    let inString = false;
+    let quote = '';
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i];
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === quote) {
+                inString = false;
+                quote = '';
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            quote = ch;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            let j = i + 1;
+            while (j < input.length && /\s/.test(input[j]))
+                j += 1;
+            if (j < input.length && (input[j] === '}' || input[j] === ']'))
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function parseJsonWithJsoncFallback(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        try {
+            const sanitized = stripTrailingCommas(stripJsoncComments(raw));
+            return JSON.parse(sanitized);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** Read and parse an MCP config file. Returns null on any error. */
+function readMCPConfig(filePath) {
+    try {
+        if (!existsSync(filePath))
+            return null;
+        return parseJsonWithJsoncFallback(readFileSync(filePath, 'utf-8'));
+    }
+    catch (error) {
+        console.error(`Error reading ${filePath}:`, error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}
+/** Read and parse a JSON file. Warns on permission errors, returns null on any failure. */
+function readJSONFile(filePath) {
+    try {
+        if (!existsSync(filePath))
+            return null;
+        return parseJsonWithJsoncFallback(readFileSync(filePath, 'utf-8'));
+    }
+    catch (error) {
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+            console.warn(`Permission denied reading ${filePath} (may require elevated permissions)`);
+        }
+        return null;
+    }
+}
+/** Read a text/markdown file. Warns on permission errors, returns null on any failure. */
+function readMarkdownFile(filePath) {
+    try {
+        if (!existsSync(filePath))
+            return null;
+        return readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+            console.warn(`Permission denied reading ${filePath} (may require elevated permissions)`);
+        }
+        return null;
+    }
+}
+/** Read installed extensions from Cursor extensions cache file. */
+function readInstalledExtensions(extensionsCachePath) {
+    const pathToRead = extensionsCachePath;
+    const extensions = [];
+    try {
+        if (!existsSync(pathToRead))
+            return extensions;
+        const data = JSON.parse(readFileSync(pathToRead, 'utf-8'));
+        if (data.result && Array.isArray(data.result)) {
+            for (const ext of data.result) {
+                const id = ext.identifier?.id;
+                if (id) {
+                    extensions.push({
+                        id,
+                        displayName: ext.manifest?.displayName || ext.manifest?.publisher || '',
+                        version: ext.manifest?.version || '',
+                        publisher: ext.manifest?.publisher,
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading installed extensions from cache (${pathToRead}):`, error instanceof Error ? error.message : String(error));
+    }
+    return extensions;
+}
+/** Parse TOML text into a nested object. Returns null on parse failure. */
+function parseTomlText(raw) {
+    try {
+        const parsed = parseToml(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Serialize a nested object to TOML (used when writing remediated .toml configs). */
+function stringifyToml(value) {
+    return stringifyTomlValue(value);
+}
+export { readMCPConfig, readJSONFile, readMarkdownFile, readInstalledExtensions, parseJsonWithJsoncFallback, parseTomlText, stringifyToml, };

package/dist/log_config_files/readers/vscdb_config_builder.js

@@ -0,0 +1,148 @@
+import { homedir } from 'node:os';
+import { readVSCDBState } from './vscdb_reader.js';
+import { getVscdbPath } from '../paths/path_constants_helpers.js';
+import { getByPath } from '../collection/enrichment_helpers.js';
+import { hookRunLog } from '../runtime/hook_logger.js';
+/** True if path is a vscdb virtual path (db file or db#fragment). Uses backend vscdb_basename and vscdb_entry_specs only. */
+export function isVscdbVirtualPath(filePath, response) {
+    if (!response?.vscdb_entry_specs?.length)
+        return false;
+    const norm = filePath.replace(/\\/g, '/');
+    if (norm.includes('#')) {
+        const fragment = '#' + norm.split('#').slice(1).join('#');
+        if (response.vscdb_entry_specs.some((s) => s.path_suffix === fragment))
+            return true;
+    }
+    if (response.vscdb_basename && (norm.endsWith(response.vscdb_basename) || norm.endsWith(response.vscdb_basename + '#')))
+        return true;
+    return false;
+}
+/**
+ * If path is a vscdb virtual path per API response, read DB and build raw_content + file_type; else return null.
+ * Caller uses this so main_runner has no state.vscdb branches.
+ */
+export function tryReadVscdbVirtualFile(filePath, response) {
+    if (!response?.vscdb_entry_specs?.length)
+        return null;
+    const norm = filePath.replace(/\\/g, '/');
+    const actualPath = norm.split('#')[0];
+    const pathSuffix = norm.includes('#') ? '#' + norm.split('#').slice(1).join('#') : '#composerState';
+    const spec = response.vscdb_entry_specs.find((s) => s.path_suffix === pathSuffix) ?? response.vscdb_entry_specs.find((s) => s.path_suffix === '#composerState');
+    if (!spec)
+        return null;
+    const isAbsolute = actualPath.startsWith('/') || (actualPath.length >= 2 && actualPath[1] === ':');
+    if (!response.client_path_constants)
+        throw new Error('client_path_constants required from API response to resolve vscdb path');
+    const defaultVscdbPath = getVscdbPath(homedir(), response.client_path_constants);
+    const dbPath = isAbsolute ? actualPath : defaultVscdbPath;
+    const vscdbState = readVSCDBState(dbPath, response.vscdb_read_queries ?? undefined, response.vscdb_merge_from_composer_state ?? undefined);
+    if (!vscdbState)
+        return null;
+    const rawContent = buildVscdbRawContentFromSpec(vscdbState, spec);
+    if (!rawContent)
+        return null;
+    return { rawContent, fileType: spec.file_type };
+}
+function setNested(obj, dotPath, value) {
+    const parts = dotPath.split('.');
+    const safe = (k) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype';
+    if (!parts.every(safe))
+        return;
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const p = parts[i];
+        if (!(p in cur) || typeof cur[p] !== 'object')
+            cur[p] = Object.create(null);
+        cur = cur[p];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+function buildRawContent(state, stateKey, value, includeKeys, ts) {
+    const raw = { source: 'state.vscdb', extracted_at: ts };
+    if (stateKey.includes('.')) {
+        setNested(raw, stateKey, value);
+    }
+    else {
+        raw[stateKey] = value;
+    }
+    // Shadow keys are merged into composerState during readVSCDBState; do not copy stale blob-root
+    // copies onto the upload payload (policy paths are composerState.<key> only).
+    if (includeKeys?.length && stateKey !== 'composerState') {
+        for (const k of includeKeys) {
+            if (k in state && state[k] !== undefined)
+                raw[k] = state[k];
+        }
+    }
+    return raw;
+}
+/** Build raw_content for a single state.vscdb fragment from a backend spec. Validation uses spec.value_constraint only. */
+function buildVscdbRawContentFromSpec(state, spec) {
+    const value = getByPath(state, spec.state_key);
+    if (value === undefined || value === null)
+        return null;
+    if (spec.value_constraint === 'non_empty_array') {
+        if (!Array.isArray(value) || value.length === 0)
+            return null;
+    }
+    if (spec.value_constraint === 'boolean') {
+        const okBool = typeof value === 'boolean';
+        const okSqliteInt = typeof value === 'number' && (value === 0 || value === 1);
+        if (!okBool && !okSqliteInt)
+            return null;
+    }
+    return buildRawContent(state, spec.state_key, value, spec.include_keys, new Date().toISOString());
+}
+/**
+ * Build config file entries from state.vscdb using backend-driven specs and read queries.
+ * No hardcoded file_type, path fragments, or ItemTable keys; all from API.
+ */
+function summarizeComposerStateValue(composerState) {
+    if (composerState === null || composerState === undefined || typeof composerState !== 'object' || Array.isArray(composerState)) {
+        return `composerState_type=${composerState === null ? 'null' : typeof composerState}`;
+    }
+    const o = composerState;
+    const m4 = o.modes4;
+    if (!Array.isArray(m4))
+        return `modes4=${m4 === undefined ? 'absent' : typeof m4}`;
+    const agent = m4.find((x) => x !== null && typeof x === 'object' && !Array.isArray(x) && x.id === 'agent');
+    if (!agent)
+        return `modes4_len=${m4.length} agent_row=missing`;
+    return `modes4_len=${m4.length} agent_autoRun=${JSON.stringify(agent.autoRun)} agent_fullAutoRun=${JSON.stringify(agent.fullAutoRun)}`;
+}
+/** Exported for main_runner: one-line summary of uploaded #composerState payload (policy full-auto-run input). */
+export function summarizeComposerPayloadForDiagnostics(raw) {
+    const inner = summarizeComposerStateValue(raw.composerState);
+    const rawKeys = Object.keys(raw)
+        .filter((k) => k !== 'source' && k !== 'extracted_at')
+        .slice(0, 16);
+    return `${inner} payload_keys=[${rawKeys.join(',')}]`;
+}
+function collectVscdbEntries(vscdbPath, specs, readQueries, mergeFromComposerState) {
+    if (!specs?.length)
+        return [];
+    const state = readVSCDBState(vscdbPath, readQueries, mergeFromComposerState);
+    if (!state || typeof state !== 'object') {
+        hookRunLog(`diag vscdb collect: readVSCDBState returned null/invalid vscdb=${vscdbPath}`);
+        return [];
+    }
+    const sk = Object.keys(state);
+    hookRunLog(`diag vscdb collect: readVSCDBState ok vscdb=${vscdbPath} top_keys=[${sk.slice(0, 24).join(',')}] ${summarizeComposerStateValue(state.composerState)}`);
+    const entries = [];
+    for (const spec of specs) {
+        const atPath = getByPath(state, spec.state_key);
+        const rawContent = buildVscdbRawContentFromSpec(state, spec);
+        if (!rawContent) {
+            if (spec.state_key === 'composerState' || spec.path_suffix === '#composerState') {
+                hookRunLog(`diag vscdb collect: skipped composer emit value_constraint=${spec.value_constraint ?? 'none'} at_path=${atPath === undefined ? 'undefined' : atPath === null ? 'null' : typeof atPath} path_suffix=${spec.path_suffix}`);
+            }
+            continue;
+        }
+        entries.push({
+            file_type: spec.file_type,
+            file_path: `${vscdbPath}${spec.path_suffix}`,
+            raw_content: rawContent,
+        });
+    }
+    return entries;
+}
+export { collectVscdbEntries, buildVscdbRawContentFromSpec };

package/dist/log_config_files/readers/vscdb_reactive_storage.js

@@ -0,0 +1,62 @@
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { readFileCollectionVscdbContract } from '../runtime/management_storage.js';
+import { resolveSqlite3Binary } from '../runtime/sqlite_binary.js';
+import { CURSOR_COMPOSER_SHADOW_KEYS } from './cursor_shadow_merge_ruleset.js';
+/** Suffix shared by Cursor reactive-storage ItemTable keys (see file_path_registry cursor agent). */
+export const REACTIVE_STORAGE_ITEM_KEY_SUFFIX = 'reactiveStorageServiceImpl.persistentStorage.applicationUser';
+function querySqliteValue(dbPath, key) {
+    const bin = resolveSqlite3Binary();
+    if (!bin)
+        return '';
+    const safe = key.replace(/'/g, "''");
+    const script = `.timeout 60000\nSELECT value FROM ItemTable WHERE key='${safe}';\n`;
+    return execFileSync(bin, ['-noheader', dbPath], {
+        input: script,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+/** When the cached contract is empty/stale, discover the live reactive blob row in state.vscdb. */
+export function discoverReactiveStorageItemKeyInVscdb(dbPath) {
+    if (!existsSync(dbPath) || !resolveSqlite3Binary())
+        return undefined;
+    try {
+        const suffix = REACTIVE_STORAGE_ITEM_KEY_SUFFIX.replace(/'/g, "''");
+        const key = execFileSync(resolveSqlite3Binary(), [
+            dbPath,
+            `SELECT key FROM ItemTable WHERE key LIKE '%${suffix}%' LIMIT 1;`,
+        ], { encoding: 'utf8' }).trim();
+        if (!key || /['"\\]/.test(key))
+            return undefined;
+        const raw = querySqliteValue(dbPath, key);
+        if (!raw || raw === '{}')
+            return undefined;
+        return key;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function reactiveStorageItemKeyFromContract() {
+    const k = readFileCollectionVscdbContract()?.reactive_storage_item_key;
+    return typeof k === 'string' && k.trim() !== '' ? k.trim() : undefined;
+}
+export function reactiveStorageItemKeyForVscdb(dbPath) {
+    const fromContract = reactiveStorageItemKeyFromContract();
+    if (fromContract)
+        return fromContract;
+    if (dbPath)
+        return discoverReactiveStorageItemKeyInVscdb(dbPath);
+    return undefined;
+}
+export function composerShadowKeysFromContract() {
+    const fromContract = readFileCollectionVscdbContract()?.composer_shadow_keys ?? [];
+    if (fromContract.length > 0)
+        return [...fromContract];
+    return [...CURSOR_COMPOSER_SHADOW_KEYS];
+}
+export function reactiveBlobHasUsableContent(dbPath, reactiveKey) {
+    const raw = querySqliteValue(dbPath, reactiveKey).trim();
+    return raw !== '' && raw !== '{}';
+}