log-llm-config 1.0.20 → 1.0.22

package/dist/log_config_files.js

@@ -6,7 +6,7 @@ import { homedir } from 'node:os';
 import crypto from 'node:crypto';
 import { execSync } from 'node:child_process';
 import path from 'node:path';
-import { getFileCollectionPatterns, patchPayload, postStartupPayload } from './endpoint_client.js';
+import { getFileCollectionPatterns, patchPayload, postStartupPayload, } from './endpoint_client.js';
 import { runSensitivePathsAudit } from './log_sensitive_paths_audit.js';
 const AUTH_KEY_RELATIVE_PATH = path.join('opt-ai-sec', 'management', 'auth_key.txt');
 /** Claude installed plugins manifest (cache-based installs). */
@@ -339,6 +339,20 @@ function collectConfigFilesFromPatterns(patterns, projectRoot) {
     const home = homedir();
     const seenPaths = new Set();
     const targets = [];
+    const enrichByFileType = {};
+    for (const p of patterns) {
+        if (p.enrich && !enrichByFileType[p.file_type])
+            enrichByFileType[p.file_type] = p.enrich;
+    }
+    // Openclaw: we only collect package.json files (no version enrichment here; backend uses them in resource generation).
+    if (!enrichByFileType['openclaw_config']) {
+        enrichByFileType['openclaw_config'] = {
+            installs_path: 'plugins.installs',
+            installs_path_fallback: 'installs',
+            installs_shape: 'object',
+            id_field: 'id',
+        };
+    }
     for (const { path_pattern, file_type } of patterns) {
         for (const t of resolvePatternToTargets(path_pattern, file_type, projectRoot, home)) {
             const key = `${t.path}\t${t.file_type}`;
@@ -442,14 +456,27 @@ function collectConfigFilesFromPatterns(patterns, projectRoot) {
             const vscdbState = readVSCDBState();
             if (vscdbState) {
                 if (vscdbState.composerState) {
+                    const webToolsTopKeys = [
+                        'lastBrowserConnectionMode',
+                        'playwrightProtection',
+                        'isWebSearchToolEnabled',
+                        'isWebFetchToolEnabled',
+                        'autoAcceptWebSearchTool',
+                    ];
+                    const rawContent = {
+                        composerState: vscdbState.composerState,
+                        source: 'state.vscdb',
+                        extracted_at: new Date().toISOString(),
+                    };
+                    for (const key of webToolsTopKeys) {
+                        if (key in vscdbState && vscdbState[key] !== undefined) {
+                            rawContent[key] = vscdbState[key];
+                        }
+                    }
                     configFiles.push({
                         file_type: 'vscode_settings',
                         file_path: `${VSCDB_PATH}#composerState`,
-                        raw_content: {
-                            composerState: vscdbState.composerState,
-                            source: 'state.vscdb',
-                            extracted_at: new Date().toISOString(),
-                        },
+                        raw_content: rawContent,
                     });
                 }
                 const chat = vscdbState.chat;
@@ -546,15 +573,120 @@ function collectConfigFilesFromPatterns(patterns, projectRoot) {
             else {
                 raw = typeof content === 'string' ? { content, source: 'file' } : content;
             }
+            const recipe = enrichByFileType[t.file_type];
+            if (recipe && typeof raw === 'object' && raw !== null) {
+                enrichRawFromRecipe(raw, recipe);
+            }
             configFiles.push({
                 file_type: t.file_type,
                 file_path: t.logicalFilePath ?? t.path,
                 raw_content: raw,
             });
+            // Openclaw: collect each install's package.json for backend to use in resource generation (version, etc.)
+            if (t.file_type === 'openclaw_config' && typeof raw === 'object' && raw !== null) {
+                pushOpenclawPackageJsonFiles(raw, configFiles);
+            }
         }
     }
     return configFiles;
 }
+/**
+ * For openclaw_config raw content, push one openclaw_package_json config file per install path
+ * (installPath/package.json or sourcePath/package.json). Backend uses these during resource generation.
+ */
+function pushOpenclawPackageJsonFiles(raw, configFiles) {
+    let installs = getByPath(raw, 'plugins.installs');
+    if (!installs)
+        installs = getByPath(raw, 'installs');
+    if (!installs)
+        return;
+    const entries = Array.isArray(installs)
+        ? installs.filter((e) => typeof e === 'object' && e !== null)
+        : typeof installs === 'object' && installs !== null
+            ? Object.values(installs).filter((e) => typeof e === 'object' && e !== null)
+            : [];
+    for (const entry of entries) {
+        const basePath = (entry.installPath ?? entry.sourcePath ?? '').trim();
+        if (!basePath)
+            continue;
+        const pkgPath = join(basePath, 'package.json');
+        const pkg = readJSONFile(pkgPath);
+        if (pkg) {
+            configFiles.push({
+                file_type: 'openclaw_package_json',
+                file_path: pkgPath,
+                raw_content: pkg,
+            });
+        }
+    }
+}
+/**
+ * Get a nested value from raw by dot-notation path (e.g. "plugins.installs").
+ */
+function getByPath(obj, path) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+/**
+ * Enrich raw_content using backend-provided recipe. Flow: 1) install manifest (path from recipe),
+ * 2) read install location from each entry, 3) find file (path_template), 4) read version_key.
+ * Mutates raw in place. Only runs when recipe has version_from_file and installs_path.
+ */
+function enrichRawFromRecipe(raw, recipe) {
+    const installsPath = recipe.installs_path ?? recipe.installs_path_fallback;
+    if (!installsPath)
+        return;
+    let installs = getByPath(raw, installsPath);
+    if (!installs && recipe.installs_path_fallback && recipe.installs_path_fallback !== installsPath) {
+        installs = getByPath(raw, recipe.installs_path_fallback);
+    }
+    if (!installs)
+        return;
+    const vf = recipe.version_from_file;
+    if (!vf?.version_key)
+        return;
+    const resolveVersion = (e) => {
+        // 1) Use version from install manifest if present
+        const v = e.version;
+        if (v !== undefined && v !== null && (typeof v !== 'string' || v.trim() !== ''))
+            return;
+        // 2) Else get from installPath/package.json (or sourcePath/package.json)
+        const installPath = e.installPath?.trim();
+        const sourcePath = e.sourcePath?.trim();
+        const basePath = installPath || sourcePath;
+        if (!basePath)
+            return;
+        const pkgPath = join(basePath, 'package.json');
+        const pkg = readJSONFile(pkgPath);
+        const versionKey = vf.version_key;
+        const versionVal = versionKey && pkg ? pkg[versionKey] : undefined;
+        if (typeof versionVal === 'string')
+            e.version = versionVal.trim();
+    };
+    if (recipe.installs_shape === 'array' && Array.isArray(installs)) {
+        for (const entry of installs) {
+            if (typeof entry === 'object' && entry !== null)
+                resolveVersion(entry);
+        }
+    }
+    else if (typeof installs === 'object' && installs !== null) {
+        for (const key of Object.keys(installs)) {
+            const entry = installs[key];
+            if (typeof entry === 'object' && entry !== null) {
+                const e = entry;
+                if (recipe.installs_shape === 'object' && !('id' in e && e.id != null))
+                    e.id = key;
+                resolveVersion(e);
+            }
+        }
+    }
+}
 /**
  * Read and parse an MCP config file
  */
@@ -1257,10 +1389,26 @@ function readVSCDBState(dbPath) {
             if (composerResult && composerResult !== '') {
                 try {
                     const parsed = JSON.parse(composerResult);
-                    // Extract composerState from the nested structure
-                    const composerState = parsed?.composerState || parsed;
-                    if (composerState && typeof composerState === 'object') {
-                        stateData.composerState = composerState;
+                    if (parsed && typeof parsed === 'object') {
+                        // Extract composerState from the nested structure
+                        const composerState = (parsed.composerState ?? parsed);
+                        if (composerState && typeof composerState === 'object') {
+                            stateData.composerState = composerState;
+                        }
+                        // Cursor may store lastBrowserConnectionMode (and other Web Tools keys) at the top level
+                        // of the reactive storage blob. Include them so the backend can merge into composerState.
+                        const topLevelKeys = [
+                            'lastBrowserConnectionMode',
+                            'playwrightProtection',
+                            'isWebSearchToolEnabled',
+                            'isWebFetchToolEnabled',
+                            'autoAcceptWebSearchTool',
+                        ];
+                        for (const key of topLevelKeys) {
+                            if (key in parsed && parsed[key] !== undefined) {
+                                stateData[key] = parsed[key];
+                            }
+                        }
                     }
                 }
                 catch (parseError) {
@@ -1527,16 +1675,30 @@ function collectConfigFiles() {
     const vscdbState = readVSCDBState();
     if (vscdbState) {
         console.log(`Found Cursor state data at: ${VSCDB_PATH}`);
-        // Store composerState as vscode_settings (general VS Code/Cursor state)
+        // Store composerState as vscode_settings (general VS Code/Cursor state).
+        // Include top-level keys (e.g. lastBrowserConnectionMode) so backend can merge into composerState for Web Tools policy.
         if (vscdbState.composerState) {
+            const topLevelKeys = [
+                'lastBrowserConnectionMode',
+                'playwrightProtection',
+                'isWebSearchToolEnabled',
+                'isWebFetchToolEnabled',
+                'autoAcceptWebSearchTool',
+            ];
+            const rawContent = {
+                composerState: vscdbState.composerState,
+                source: 'state.vscdb',
+                extracted_at: new Date().toISOString(),
+            };
+            for (const key of topLevelKeys) {
+                if (key in vscdbState && vscdbState[key] !== undefined) {
+                    rawContent[key] = vscdbState[key];
+                }
+            }
             configFiles.push({
                 file_type: 'vscode_settings',
                 file_path: `${VSCDB_PATH}#composerState`, // Use fragment to distinguish
-                raw_content: {
-                    composerState: vscdbState.composerState,
-                    source: 'state.vscdb',
-                    extracted_at: new Date().toISOString(),
-                },
+                raw_content: rawContent,
             });
         }
         // Store chat.tools as vscode_settings (for chat.tools.autoApprove policy)
@@ -2486,6 +2648,13 @@ async function logSingleFile(filePath) {
         // Read the SQLite database using the provided path
         const vscdbState = readVSCDBState(actualPath);
         if (vscdbState) {
+            const webToolsTopKeys = [
+                'lastBrowserConnectionMode',
+                'playwrightProtection',
+                'isWebSearchToolEnabled',
+                'isWebFetchToolEnabled',
+                'autoAcceptWebSearchTool',
+            ];
             // Check if there's a fragment (e.g., "#composerState" or "#chat.tools")
             const fragment = filePath.includes('#') ? filePath.split('#')[1] : null;
             if (fragment === 'composerState' && vscdbState.composerState) {
@@ -2494,6 +2663,11 @@ async function logSingleFile(filePath) {
                     source: 'state.vscdb',
                     extracted_at: new Date().toISOString(),
                 };
+                for (const key of webToolsTopKeys) {
+                    if (key in vscdbState && vscdbState[key] !== undefined) {
+                        rawContent[key] = vscdbState[key];
+                    }
+                }
                 fileType = 'vscode_settings';
             }
             else if (fragment === 'chat.tools' && vscdbState.chat) {
@@ -2540,6 +2714,11 @@ async function logSingleFile(filePath) {
                     source: 'state.vscdb',
                     extracted_at: new Date().toISOString(),
                 };
+                for (const key of webToolsTopKeys) {
+                    if (key in vscdbState && vscdbState[key] !== undefined) {
+                        rawContent[key] = vscdbState[key];
+                    }
+                }
                 fileType = 'vscode_settings';
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "log-llm-config",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {