log-llm-config-staging 1.3.44

package/dist/log_config_files/readers/vscdb_reader.js

@@ -0,0 +1,247 @@
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { resolveSqlite3Binary } from '../runtime/sqlite_binary.js';
+import { readFileCollectionVscdbContract, writeFileCollectionVscdbContract, } from '../runtime/management_storage.js';
+/**
+ * ItemTable keys that store a bare JSON boolean; compliance paths use `${key}.${field}`.
+ * Kept in sync with `coerceItemTableValueToObjectRoot` / `serializeItemTableValueForWrite` in remediation_sync.
+ */
+export const CURSOR_SCALAR_ITEMTABLE_FIELDS = {
+    'cursor/thirdPartyExtensibilityEnabled': 'thirdPartyExtensibilityEnabled',
+    'cursorai/donotchange/privacyMode': 'privacyMode',
+    'cursor/autoOpenLocalhostUrls': 'autoOpenLocalhostUrls',
+};
+function querySqlite(dbPath, key) {
+    const bin = resolveSqlite3Binary();
+    if (!bin)
+        throw new Error('sqlite3 not found');
+    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();
+}
+/**
+ * Fallback if the API omits vscdb_composer_contract (older server): derive from vscdb_read_queries.
+ */
+export function parseVscdbComposerContractFromReadQueries(queries) {
+    const empty = {
+        version: 1,
+        reactive_storage_item_key: undefined,
+        composer_shadow_keys: [],
+    };
+    if (!queries?.length)
+        return empty;
+    for (const step of queries) {
+        if (step.value_kind === 'composer_with_include' && step.state_key === 'composerState') {
+            const keys = step.item_table_keys ?? [];
+            return {
+                version: 1,
+                reactive_storage_item_key: keys[0],
+                composer_shadow_keys: [...(step.include_keys ?? [])],
+            };
+        }
+    }
+    return empty;
+}
+export function normalizeVscdbComposerContractFromPatternsResponse(resp) {
+    const c = resp.vscdb_composer_contract;
+    const hasKey = c != null &&
+        ((typeof c.reactive_storage_item_key === 'string' && c.reactive_storage_item_key.trim() !== '') ||
+            (c.composer_shadow_keys?.length ?? 0) > 0);
+    if (hasKey && c) {
+        return {
+            version: 1,
+            reactive_storage_item_key: c.reactive_storage_item_key ?? undefined,
+            composer_shadow_keys: [...(c.composer_shadow_keys ?? [])],
+        };
+    }
+    return parseVscdbComposerContractFromReadQueries(resp.vscdb_read_queries);
+}
+/** Persist backend-derived contract next to remediation_instructions.json. */
+export function persistVscdbComposerContractFromPatternsResponse(resp) {
+    const norm = normalizeVscdbComposerContractFromPatternsResponse(resp);
+    if (norm.reactive_storage_item_key || norm.composer_shadow_keys.length > 0) {
+        writeFileCollectionVscdbContract(norm);
+    }
+}
+/**
+ * Read one ItemTable JSON blob (e.g. key `composerState`) and return `{ [itemKey]: object }` so
+ * dot-paths like `composerState.modes4.agent.autoRun` (or legacy numeric `modes4.0`) work in compliance checks. Empty / missing value
+ * yields `{ [itemKey]: {} }`. Returns null if the DB is missing, sqlite3 is unavailable, or JSON parse fails.
+ *
+ * When `file_collection_vscdb_contract.json` lists `reactive_storage_item_key`, a missing legacy `composerState` row
+ * falls back to nested `composerState` inside that reactive blob (paths from the backend API only).
+ */
+export function readVscdbItemTableJson(dbPath, itemKey) {
+    try {
+        if (!dbPath || !existsSync(dbPath))
+            return null;
+        if (!resolveSqlite3Binary())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    try {
+        const raw = querySqlite(dbPath, itemKey);
+        const contract = readFileCollectionVscdbContract();
+        const reactiveKey = typeof contract?.reactive_storage_item_key === 'string' ? contract.reactive_storage_item_key.trim() : '';
+        if (itemKey === 'composerState' && (!raw || raw === '{}') && reactiveKey) {
+            const reactive = querySqlite(dbPath, reactiveKey);
+            if (reactive) {
+                const root = JSON.parse(reactive);
+                const cs = root.composerState;
+                if (cs !== null && typeof cs === 'object' && !Array.isArray(cs)) {
+                    return { composerState: cs };
+                }
+            }
+        }
+        if (!raw) {
+            return { [itemKey]: {} };
+        }
+        const parsed = JSON.parse(raw);
+        if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return { [itemKey]: parsed };
+        }
+        // Bare JSON primitives. Scalar toggles must be wrapped so getByPath(key.field) works in compliance checks.
+        // Match coerceScalarForItemTableField in remediation_sync: Cursor may store toggles as JSON 0/1, not only booleans.
+        if (typeof parsed === 'boolean' || typeof parsed === 'number' || typeof parsed === 'string') {
+            const field = CURSOR_SCALAR_ITEMTABLE_FIELDS[itemKey];
+            if (field) {
+                if (typeof parsed === 'boolean') {
+                    return { [itemKey]: { [field]: parsed } };
+                }
+                if (typeof parsed === 'number' && !Number.isNaN(parsed)) {
+                    return { [itemKey]: { [field]: parsed !== 0 } };
+                }
+                if (typeof parsed === 'string') {
+                    const lower = parsed.trim().toLowerCase();
+                    return {
+                        [itemKey]: { [field]: lower === 'true' || lower === '1' || lower === 'yes' },
+                    };
+                }
+            }
+            return { [itemKey]: parsed };
+        }
+        return { [itemKey]: {} };
+    }
+    catch {
+        return null;
+    }
+}
+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 runOneStep(dbPath, stateData, step) {
+    for (const key of step.item_table_keys) {
+        try {
+            const result = querySqlite(dbPath, key);
+            if (!result)
+                continue;
+            if (step.value_kind === 'boolean') {
+                const lower = result.toLowerCase();
+                setNested(stateData, step.state_key, lower === 'true' || lower === '1' || lower === 'yes');
+                return;
+            }
+            const parsed = JSON.parse(result);
+            if (step.value_kind === 'composer_with_include') {
+                if (!parsed || typeof parsed !== 'object')
+                    continue;
+                const obj = parsed;
+                const composerState = (obj.composerState ?? obj);
+                if (composerState && typeof composerState === 'object') {
+                    stateData.composerState = composerState;
+                }
+                if (step.include_keys?.length) {
+                    const nested = composerState && typeof composerState === 'object'
+                        ? composerState
+                        : undefined;
+                    for (const k of step.include_keys) {
+                        // Prefer the value inside composerState when present; blob root can be stale vs the UI.
+                        if (nested && k in nested && nested[k] !== undefined) {
+                            stateData[k] = nested[k];
+                        }
+                        else if (k in obj && obj[k] !== undefined) {
+                            stateData[k] = obj[k];
+                        }
+                    }
+                }
+                return;
+            }
+            if (step.value_kind === 'json_array_or_object') {
+                if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    setNested(stateData, step.state_key, Object.keys(parsed));
+                }
+                else if (Array.isArray(parsed)) {
+                    setNested(stateData, step.state_key, parsed);
+                }
+                return;
+            }
+            if (step.value_kind === 'json') {
+                if (parsed !== null && typeof parsed === 'object') {
+                    setNested(stateData, step.state_key, parsed);
+                }
+                return;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+}
+function mergeFromComposerState(stateData, mergeKeys) {
+    const composer = stateData.composerState;
+    if (!composer || typeof composer !== 'object')
+        return;
+    const composerState = composer;
+    for (const key of mergeKeys) {
+        if (key in stateData && stateData[key] !== undefined)
+            continue;
+        if (key in composerState && composerState[key] !== undefined) {
+            stateData[key] = composerState[key];
+        }
+    }
+}
+/**
+ * Read state from a vscdb file using backend-driven queries only (no hardcoded keys).
+ * dbPath must be provided (e.g. from API client_path_constants via getVscdbPath); no default path.
+ * Constants come from API vscdb_read_queries and vscdb_merge_from_composer_state (backend utils/queries.py).
+ */
+export function readVSCDBState(dbPath, readQueries, mergeFromComposerStateKeys) {
+    try {
+        if (!dbPath || !existsSync(dbPath))
+            return null;
+        if (!resolveSqlite3Binary()) {
+            console.warn('sqlite3 command not found; skipping vscdb reading');
+            return null;
+        }
+        if (!readQueries?.length)
+            return null;
+        const stateData = {};
+        for (const step of readQueries) {
+            runOneStep(dbPath, stateData, step);
+        }
+        if (mergeFromComposerStateKeys?.length) {
+            mergeFromComposerState(stateData, mergeFromComposerStateKeys);
+        }
+        return Object.keys(stateData).length > 0 ? stateData : null;
+    }
+    catch (error) {
+        console.error(`Error reading vscdb:`, error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}