log-llm-config 1.0.19 → 1.0.22

package/dist/endpoint_client.js

@@ -194,6 +194,81 @@ export const postStartupPayload = async (endpointUrl, body, timeoutMs = 5000) =>
         req.end();
     });
 };
+/**
+ * PATCH request to endpoint (same transport as postStartupPayload: Node http/https,
+ * localhost → 127.0.0.1). Used for hook-request manifest update so it behaves like other endpoint calls.
+ */
+export const patchPayload = async (endpointUrl, body, timeoutMs = 10000) => {
+    const url = new URL(endpointUrl);
+    const isHttps = url.protocol === 'https:';
+    let hostname = url.hostname;
+    if (hostname === 'localhost' || hostname === '::1') {
+        hostname = '127.0.0.1';
+    }
+    const payload = JSON.stringify(body);
+    const requestOptions = {
+        hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: `${url.pathname}${url.search}`,
+        method: 'PATCH',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(payload).toString(),
+        },
+        timeout: timeoutMs,
+    };
+    const transport = isHttps ? https.request : http.request;
+    return new Promise((resolve, reject) => {
+        let timeoutId = null;
+        let requestCompleted = false;
+        const cleanup = () => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        };
+        const req = transport(requestOptions, (res) => {
+            let responseBody = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                responseBody += chunk;
+            });
+            res.on('end', () => {
+                requestCompleted = true;
+                cleanup();
+                if (!responseBody) {
+                    resolve({ status: 'error', error: 'empty_response' });
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(responseBody));
+                }
+                catch {
+                    reject(new Error(`Invalid JSON: ${responseBody.slice(0, 200)}`));
+                }
+            });
+        });
+        req.on('error', (error) => {
+            requestCompleted = true;
+            cleanup();
+            reject(error);
+        });
+        req.on('timeout', () => {
+            requestCompleted = true;
+            cleanup();
+            req.destroy();
+            reject(new Error(`Request timeout after ${timeoutMs}ms`));
+        });
+        timeoutId = setTimeout(() => {
+            if (!requestCompleted) {
+                req.destroy();
+                reject(new Error(`Request timeout after ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+        req.write(payload);
+        req.end();
+    });
+};
 export const classifyEndpointResponse = (response) => {
     if (response.status === 'key_issued' && response.key) {
         return {

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, 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). */
@@ -122,6 +122,8 @@ const JSON_FILE_PATHS = [
 const VSCDB_PATH = join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
 // Cursor extensions cache file path
 const EXTENSIONS_CACHE_PATH = join(homedir(), 'Library', 'Application Support', 'Cursor', 'CachedProfilesData', '__default__profile__', 'extensions.user.cache');
+// Cursor MCP tool cache: ~/.cursor/projects/<project>/mcps/<server>/tools/*.json
+const CURSOR_PROJECTS_PATH = join(homedir(), '.cursor', 'projects');
 // Claude configuration file paths
 const CLAUDE_FILE_PATHS = [
     // Project Root
@@ -221,13 +223,58 @@ function expandGlobPathPattern(pathPattern, fileType, home, projectRoot) {
     }
     return targets;
 }
+/**
+ * Expand Cursor MCP tool cache path to one target per tool file.
+ * Path: ~/.cursor/projects/<project>/mcps/<server>/tools/*.json
+ * Uses logicalFilePath (project_id/mcps/server_id/tools/name.json) for the payload.
+ */
+function expandMcpToolGlobPattern(home) {
+    const targets = [];
+    const projectsPath = join(home, '.cursor', 'projects');
+    if (!existsSync(projectsPath))
+        return targets;
+    try {
+        const projectDirs = readdirSync(projectsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+        for (const projectDir of projectDirs) {
+            const mcpsPath = join(projectsPath, projectDir.name, 'mcps');
+            if (!existsSync(mcpsPath))
+                continue;
+            const serverDirs = readdirSync(mcpsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+            for (const serverDir of serverDirs) {
+                const toolsPath = join(mcpsPath, serverDir.name, 'tools');
+                if (!existsSync(toolsPath))
+                    continue;
+                const toolFiles = readdirSync(toolsPath).filter((n) => n.endsWith('.json'));
+                for (const toolFile of toolFiles) {
+                    const fullPath = join(toolsPath, toolFile);
+                    targets.push({
+                        path: fullPath,
+                        file_type: 'mcp_tool',
+                        logicalFilePath: `${projectDir.name}/mcps/${serverDir.name}/tools/${toolFile}`,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // ignore read errors
+    }
+    return targets;
+}
 /**
  * Resolve a single (path_pattern, file_type) from the API to concrete collection targets.
  */
 function resolvePatternToTargets(pathPattern, fileType, projectRoot, home) {
     const norm = pathPattern.replace(/\\/g, '/');
     const targets = [];
-    // Glob pattern: expand ~/.claude/plugins/marketplaces/*/skills/ etc.
+    // mcp_tool: only the backend glob pattern drives collection; skip short "mcps/" (used for path classification only)
+    if (fileType === 'mcp_tool') {
+        if (norm.includes('*') && norm.includes('mcps') && norm.includes('tools')) {
+            return expandMcpToolGlobPattern(home);
+        }
+        return targets;
+    }
+    // Single-* glob pattern: expand ~/.claude/plugins/marketplaces/*/skills/ etc.
     if (norm.includes('*')) {
         return expandGlobPathPattern(pathPattern, fileType, home, projectRoot);
     }
@@ -292,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}`;
@@ -395,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;
@@ -482,6 +556,7 @@ function collectConfigFilesFromPatterns(patterns, projectRoot) {
         if (!existsSync(t.path))
             continue;
         const isJson = t.path.endsWith('.json') ||
+            t.file_type === 'mcp_tool' ||
             t.file_type === 'mcp_config' ||
             t.file_type === 'cursor_hooks' ||
             t.file_type === 'claude_settings';
@@ -498,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.path,
+                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
  */
@@ -544,6 +724,47 @@ function readJSONFile(filePath) {
         return null;
     }
 }
+/**
+ * Collect MCP tool cache files from ~/.cursor/projects/<project>/mcps/<server>/tools/*.json.
+ * Iterates all project and server directories; each tool JSON is sent as a separate file so
+ * inventory can list tools per MCP server. Path sent is logical: <project>/mcps/<server>/tools/<name>.json
+ */
+function collectMcpToolFiles() {
+    const result = [];
+    try {
+        if (!existsSync(CURSOR_PROJECTS_PATH)) {
+            return result;
+        }
+        const projectDirs = readdirSync(CURSOR_PROJECTS_PATH, { withFileTypes: true }).filter((d) => d.isDirectory());
+        for (const projectDir of projectDirs) {
+            const mcpsPath = join(CURSOR_PROJECTS_PATH, projectDir.name, 'mcps');
+            if (!existsSync(mcpsPath))
+                continue;
+            const serverDirs = readdirSync(mcpsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+            for (const serverDir of serverDirs) {
+                const toolsPath = join(mcpsPath, serverDir.name, 'tools');
+                if (!existsSync(toolsPath))
+                    continue;
+                const toolFiles = readdirSync(toolsPath).filter((n) => n.endsWith('.json'));
+                for (const toolFile of toolFiles) {
+                    const fullPath = join(toolsPath, toolFile);
+                    const content = readJSONFile(fullPath);
+                    if (content) {
+                        result.push({
+                            file_type: 'mcp_tool',
+                            file_path: `${projectDir.name}/mcps/${serverDir.name}/tools/${toolFile}`,
+                            raw_content: content,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Error collecting MCP tool files:', error instanceof Error ? error.message : String(error));
+    }
+    return result;
+}
 /**
  * Read a markdown/text file and return as content string
  */
@@ -1168,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) {
@@ -1405,6 +1642,17 @@ function collectConfigFiles() {
             });
         }
     }
+    // MCP tool files: same location as backend pattern ~/.cursor/projects/*/mcps/*/tools/*.json (see expandMcpToolGlobPattern)
+    for (const t of expandMcpToolGlobPattern(homedir())) {
+        const content = readJSONFile(t.path);
+        if (content != null) {
+            configFiles.push({
+                file_type: 'mcp_tool',
+                file_path: t.logicalFilePath ?? t.path,
+                raw_content: content,
+            });
+        }
+    }
     // Read JSON files - collect all levels (enterprise, project, user) so we can display them all
     for (const { path, file_type } of JSON_FILE_PATHS) {
         try {
@@ -1427,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)
@@ -2097,17 +2359,12 @@ async function sendHookRequestUpdateManifest(hardwareUuid, authKey, hookRequestI
     const signature = createSignature(payload, authKey.key);
     const body = { ...payload, signature, key_id: authKey.key_id || '' };
     try {
-        const response = await fetch(apiUrl, {
-            method: 'PATCH',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        });
-        const data = (await response.json());
-        if (response.ok && data.status === 'accepted') {
+        const data = (await patchPayload(apiUrl, body));
+        if (data.status === 'accepted') {
             hookRunLog(`hook-request manifest updated (${manifestNormalized.length} paths)`);
             return true;
         }
-        hookRunLog(`hook-request update failed: ${data.error || response.status}`);
+        hookRunLog(`hook-request update failed: ${data.error ?? data.status ?? 'unknown'}`);
         return false;
     }
     catch (error) {
@@ -2306,6 +2563,10 @@ function determineFileTypeFromPath(filePath) {
         normalizedPath.includes('.mcp.json')) {
         return 'mcp_config';
     }
+    // Cursor MCP tool cache: .../mcps/<server>/tools/*.json
+    if (normalizedPath.includes('mcps/') && normalizedPath.includes('/tools/')) {
+        return 'mcp_tool';
+    }
     // Claude settings (most specific first)
     if (normalizedPath.includes('/Library/Application Support/ClaudeCode/managed-settings.json')) {
         return 'claude_settings';
@@ -2387,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) {
@@ -2395,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) {
@@ -2441,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 {
@@ -2597,4 +2875,4 @@ if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.includes
         process.exit(1);
     });
 }
-export { main, collectConfigFiles, collectConfigFilesFromPatterns, collectConfigFilesFromInstalledPlugins, resolvePatternToTargets, ensureAuthentication, sendConfigFile, sendConfigFilesBatch, createSignature, canonicalizePayload, readVSCDBState, logSingleFile, };
+export { main, collectConfigFiles, collectConfigFilesFromPatterns, collectConfigFilesFromInstalledPlugins, collectMcpToolFiles, resolvePatternToTargets, ensureAuthentication, sendConfigFile, sendConfigFilesBatch, createSignature, canonicalizePayload, readVSCDBState, logSingleFile, };

package/package.json

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