log-llm-config 1.0.9 → 1.0.11

package/dist/cli.js

@@ -61,7 +61,16 @@ const main = async () => {
         return;
     }
     if (args[0] === 'log_config_files') {
-        const { main } = await import('./log_config_files.js');
+        const { main, logSingleFile } = await import('./log_config_files.js');
+        // Check if a file path was provided
+        const filePathArg = args.find((arg, idx) => idx > 0 && !arg.startsWith('-') && (arg.includes('/') || arg.endsWith('.json') || arg.endsWith('.md')));
+        if (filePathArg) {
+            // Log single file
+            const success = await logSingleFile(filePathArg);
+            process.exit(success ? 0 : 1);
+            return;
+        }
+        // Otherwise, log all files
         await main();
         return;
     }

package/dist/endpoint_client.js

@@ -1,6 +1,63 @@
 import http from 'node:http';
 import https from 'node:https';
 import { URL } from 'node:url';
+/**
+ * GET file collection patterns from the backend (what to look for).
+ * No auth required. Returns the complete list of path_pattern + file_type.
+ */
+export const getFileCollectionPatterns = async (apiBaseUrl, timeoutMs = 5000) => {
+    const base = apiBaseUrl.replace(/\/+$/, '');
+    const fullUrl = base.includes('/endpoint_security')
+        ? `${base}/api/file-patterns/`.replace(/([^/])\/+/g, '$1/')
+        : `${base}/endpoint_security/api/file-patterns/`;
+    const url = new URL(fullUrl);
+    const isHttps = url.protocol === 'https:';
+    let hostname = url.hostname;
+    if (hostname === 'localhost' || hostname === '::1') {
+        hostname = '127.0.0.1';
+    }
+    const requestOptions = {
+        hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname + url.search,
+        method: 'GET',
+        timeout: timeoutMs,
+    };
+    const transport = isHttps ? https.request : http.request;
+    return new Promise((resolve) => {
+        const req = transport(requestOptions, (res) => {
+            let responseBody = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                responseBody += chunk;
+            });
+            res.on('end', () => {
+                if (res.statusCode !== 200 || !responseBody) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(responseBody);
+                    if (Array.isArray(parsed.patterns) && typeof parsed.count === 'number') {
+                        resolve(parsed);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.end();
+    });
+};
 export const postStartupPayload = async (endpointUrl, body, timeoutMs = 5000) => {
     const url = new URL(endpointUrl);
     const isHttps = url.protocol === 'https:';

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 { postStartupPayload } from './endpoint_client.js';
+import { getFileCollectionPatterns, postStartupPayload } from './endpoint_client.js';
 const AUTH_KEY_RELATIVE_PATH = path.join('opt-ai-sec', 'management', 'auth_key.txt');
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -51,9 +51,21 @@ const JSON_FILE_PATHS = [
         path: join(homedir(), '.claude', 'settings.json'),
         file_type: 'claude_settings',
     },
+    // Project-level Claude local settings (local overrides)
+    {
+        path: join(PROJECT_ROOT, '.claude', 'settings.local.json'),
+        file_type: 'claude_settings',
+    },
+    // User-level Claude local settings (local overrides)
+    {
+        path: join(homedir(), '.claude', 'settings.local.json'),
+        file_type: 'claude_settings',
+    },
 ];
 // VS Code/Cursor state database path
 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');
 // Claude configuration file paths
 const CLAUDE_FILE_PATHS = [
     // Project Root
@@ -90,6 +102,307 @@ const PLUGIN_SEARCH_DIRS = [
     PROJECT_ROOT, // Project-level plugins
     join(homedir(), '.claude', 'plugins'), // User-level plugins (if this becomes a standard location)
 ];
+/** Glob(s) for directory scans by file_type. First match used if array. */
+const DIR_GLOB_BY_FILE_TYPE = {
+    cursor_command: '*.md',
+    cursor_rule: '*.md',
+    claude_rule: '*.md',
+    claude_subagent: '*.md',
+    cursor_subagent: '*.md',
+    claude_skill: '*.md',
+    codex_skill: '*.md',
+    claude_plugin_command: '*.md',
+    claude_plugin_manifest: 'plugin.json',
+    claude_plugin_hooks: 'hooks.json',
+    claude_plugin_mcp: '.mcp.json',
+};
+/**
+ * Expand a path pattern containing a single * into concrete directory paths.
+ * Example: ~/.claude/plugins/marketplaces/<name>/skills/ -> [ .../anthropic-agent-skills/skills, ... ].
+ */
+function expandGlobPathPattern(pathPattern, fileType, home, projectRoot) {
+    const norm = pathPattern.replace(/\\/g, '/');
+    const targets = [];
+    const asteriskIndex = norm.indexOf('*');
+    if (asteriskIndex === -1)
+        return targets;
+    const isDir = norm.endsWith('/');
+    const [before, after] = norm.split('*');
+    const beforeNorm = before.replace(/\/+$/, '');
+    const afterNorm = after.replace(/^\/+/, '');
+    let basePath;
+    if (beforeNorm.startsWith('~/')) {
+        basePath = join(home, beforeNorm.slice(2));
+    }
+    else if (beforeNorm.startsWith('/') && (beforeNorm.startsWith('/Library') || beforeNorm.startsWith('/Users') || beforeNorm.startsWith('/home'))) {
+        basePath = beforeNorm;
+    }
+    else {
+        const stripLeading = beforeNorm.startsWith('/') ? beforeNorm.slice(1) : beforeNorm;
+        basePath = join(projectRoot, stripLeading);
+    }
+    if (!existsSync(basePath))
+        return targets;
+    try {
+        const entries = readdirSync(basePath, { withFileTypes: true });
+        const glob = DIR_GLOB_BY_FILE_TYPE[fileType];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const resolvedPath = join(basePath, entry.name, afterNorm);
+            if (!existsSync(resolvedPath))
+                continue;
+            targets.push({
+                path: resolvedPath,
+                file_type: fileType,
+                isDirectory: isDir,
+                glob: Array.isArray(glob) ? glob[0] : glob,
+            });
+        }
+    }
+    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.
+    if (norm.includes('*')) {
+        return expandGlobPathPattern(pathPattern, fileType, home, projectRoot);
+    }
+    // Special: state.vscdb (any fragment) -> single target; we read and split in collection
+    if (norm.includes('state.vscdb')) {
+        targets.push({ path: VSCDB_PATH, file_type: fileType });
+        return targets;
+    }
+    // Special: extensions.user.cache#installedExtensions
+    if (norm.includes('extensions.user.cache') && norm.includes('installedExtensions')) {
+        targets.push({ path: `${EXTENSIONS_CACHE_PATH}#installedExtensions`, file_type: 'cursor_extensions' });
+        return targets;
+    }
+    const isDir = norm.endsWith('/');
+    const rel = norm.replace(/\/+$/, '');
+    const push = (p) => {
+        if (isDir) {
+            const glob = DIR_GLOB_BY_FILE_TYPE[fileType];
+            targets.push({
+                path: p,
+                file_type: fileType,
+                isDirectory: true,
+                glob: Array.isArray(glob) ? glob[0] : glob,
+            });
+        }
+        else {
+            targets.push({ path: p, file_type: fileType });
+        }
+    };
+    // Absolute path (real absolute, not /.cursor/...)
+    if (norm.startsWith('/') && (norm.startsWith('/Library') || norm.startsWith('/Users') || norm.startsWith('/home') || norm.startsWith('/etc'))) {
+        push(norm);
+        return targets;
+    }
+    // Home-relative
+    if (norm.startsWith('~/')) {
+        push(join(home, rel.slice(2)));
+        return targets;
+    }
+    // Project- or both-relative: /.cursor/..., .cursor/..., CLAUDE.md, etc.
+    const stripLeadingSlash = rel.startsWith('/') ? rel.slice(1) : rel;
+    push(join(projectRoot, stripLeadingSlash));
+    if (!stripLeadingSlash.startsWith('.')) {
+        // e.g. CLAUDE.md at project root only for first push; also at ~/.claude/CLAUDE.md
+        if (stripLeadingSlash === 'CLAUDE.md' || stripLeadingSlash === 'CLAUDE.local.md') {
+            push(join(home, '.claude', stripLeadingSlash));
+        }
+    }
+    else {
+        push(join(home, stripLeadingSlash));
+    }
+    return targets;
+}
+/**
+ * Collect config files by resolving API patterns to paths and reading existing files.
+ * Reuses readMCPConfig, readJSONFile, readMarkdownFile, readVSCDBState, readInstalledExtensions and directory scan helpers.
+ */
+function collectConfigFilesFromPatterns(patterns, projectRoot) {
+    const home = homedir();
+    const seenPaths = new Set();
+    const targets = [];
+    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}`;
+            if (seenPaths.has(key))
+                continue;
+            seenPaths.add(key);
+            targets.push(t);
+        }
+    }
+    const configFiles = [];
+    const handledSpecialPaths = new Set();
+    for (const t of targets) {
+        if (t.isDirectory) {
+            if (!existsSync(t.path))
+                continue;
+            try {
+                const entries = readdirSync(t.path, { withFileTypes: true });
+                const glob = t.glob || '*.md';
+                const matchName = (name) => glob.startsWith('*') ? name.endsWith(glob.slice(1)) : name === glob;
+                for (const entry of entries) {
+                    if (!entry.isFile())
+                        continue;
+                    if (!matchName(entry.name))
+                        continue;
+                    const fullPath = join(t.path, entry.name);
+                    const content = readMarkdownFile(fullPath) ?? readJSONFile(fullPath);
+                    if (content !== null) {
+                        const raw = typeof content === 'string' ? { content, source: 'file' } : content;
+                        configFiles.push({
+                            file_type: t.file_type,
+                            file_path: fullPath,
+                            raw_content: raw,
+                        });
+                    }
+                }
+                // cursor_rule: also support subdirs with RULE.md
+                if (t.file_type === 'cursor_rule') {
+                    for (const entry of entries) {
+                        if (!entry.isDirectory())
+                            continue;
+                        const ruleMd = join(t.path, entry.name, 'RULE.md');
+                        if (existsSync(ruleMd)) {
+                            const content = readMarkdownFile(ruleMd);
+                            if (content !== null) {
+                                configFiles.push({
+                                    file_type: t.file_type,
+                                    file_path: ruleMd,
+                                    raw_content: { content, source: 'cursor_rule_file' },
+                                });
+                            }
+                        }
+                    }
+                }
+                // claude_skill / codex_skill: also support subdirs with SKILL.md (e.g. skills/<name>/SKILL.md)
+                if (t.file_type === 'claude_skill' || t.file_type === 'codex_skill') {
+                    for (const entry of entries) {
+                        if (!entry.isDirectory())
+                            continue;
+                        const skillMd = join(t.path, entry.name, 'SKILL.md');
+                        if (existsSync(skillMd)) {
+                            const content = readMarkdownFile(skillMd);
+                            if (content !== null) {
+                                configFiles.push({
+                                    file_type: t.file_type,
+                                    file_path: skillMd,
+                                    raw_content: { content, source: 'skill_file' },
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`Error reading directory ${t.path}:`, err instanceof Error ? err.message : String(err));
+            }
+            continue;
+        }
+        // Single file or special
+        if (t.path.includes('#installedExtensions')) {
+            if (handledSpecialPaths.has(EXTENSIONS_CACHE_PATH))
+                continue;
+            handledSpecialPaths.add(EXTENSIONS_CACHE_PATH);
+            const installed = readInstalledExtensions();
+            if (installed.length > 0) {
+                configFiles.push({
+                    file_type: 'cursor_extensions',
+                    file_path: `${EXTENSIONS_CACHE_PATH}#installedExtensions`,
+                    raw_content: {
+                        installedExtensions: installed,
+                        source: 'extensions.user.cache',
+                        extracted_at: new Date().toISOString(),
+                    },
+                });
+            }
+            continue;
+        }
+        if (t.path === VSCDB_PATH) {
+            if (handledSpecialPaths.has(VSCDB_PATH))
+                continue;
+            handledSpecialPaths.add(VSCDB_PATH);
+            const vscdbState = readVSCDBState();
+            if (vscdbState) {
+                if (vscdbState.composerState) {
+                    configFiles.push({
+                        file_type: 'vscode_settings',
+                        file_path: `${VSCDB_PATH}#composerState`,
+                        raw_content: {
+                            composerState: vscdbState.composerState,
+                            source: 'state.vscdb',
+                            extracted_at: new Date().toISOString(),
+                        },
+                    });
+                }
+                const chat = vscdbState.chat;
+                if (chat?.tools) {
+                    configFiles.push({
+                        file_type: 'vscode_settings',
+                        file_path: `${VSCDB_PATH}#chat.tools`,
+                        raw_content: {
+                            chat: { tools: chat.tools },
+                            source: 'state.vscdb',
+                            extracted_at: new Date().toISOString(),
+                        },
+                    });
+                }
+                const extRec = vscdbState.extensionsAssistant;
+                if (extRec?.recommendations?.length) {
+                    configFiles.push({
+                        file_type: 'cursor_extensions',
+                        file_path: `${VSCDB_PATH}#extensionsAssistant.recommendations`,
+                        raw_content: {
+                            extensionsAssistant: { recommendations: extRec.recommendations },
+                            source: 'state.vscdb',
+                            extracted_at: new Date().toISOString(),
+                        },
+                    });
+                }
+                const ext = vscdbState.extensions;
+                if (ext?.trustedPublishers?.length) {
+                    configFiles.push({
+                        file_type: 'cursor_extensions',
+                        file_path: `${VSCDB_PATH}#extensions.trustedPublishers`,
+                        raw_content: {
+                            extensions: { trustedPublishers: ext.trustedPublishers },
+                            source: 'state.vscdb',
+                            extracted_at: new Date().toISOString(),
+                        },
+                    });
+                }
+            }
+            continue;
+        }
+        if (!existsSync(t.path))
+            continue;
+        const isJson = t.path.endsWith('.json') ||
+            t.file_type === 'mcp_config' ||
+            t.file_type === 'cursor_hooks' ||
+            t.file_type === 'claude_settings';
+        const content = isJson ? readJSONFile(t.path) ?? readMCPConfig(t.path) : readMarkdownFile(t.path);
+        if (content !== null) {
+            const raw = typeof content === 'string' ? { content, source: 'file' } : content;
+            configFiles.push({
+                file_type: t.file_type,
+                file_path: t.path,
+                raw_content: raw,
+            });
+        }
+    }
+    return configFiles;
+}
 /**
  * Read and parse an MCP config file
  */
@@ -559,10 +872,12 @@ function getSubdirectoryClaudeFiles(projectRoot) {
 /**
  * Read state data from Cursor's state.vscdb SQLite database
  * Extracts composerState, extensionsAssistant, and extensions data
+ * @param dbPath Optional path to state.vscdb file. If not provided, uses default VSCDB_PATH.
  */
-function readVSCDBState() {
+function readVSCDBState(dbPath) {
     try {
-        if (!existsSync(VSCDB_PATH)) {
+        const actualPath = dbPath || VSCDB_PATH;
+        if (!existsSync(actualPath)) {
             return null;
         }
         // Check if sqlite3 is available
@@ -580,7 +895,7 @@ function readVSCDBState() {
         const escapedComposerKey = composerStateKey.replace(/'/g, "''");
         const composerQuery = `SELECT value FROM ItemTable WHERE key='${escapedComposerKey}'`;
         try {
-            const composerResult = execSync(`sqlite3 "${VSCDB_PATH}" "${composerQuery}"`, {
+            const composerResult = execSync(`sqlite3 "${actualPath}" "${composerQuery}"`, {
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'pipe'],
             }).trim();
@@ -612,7 +927,7 @@ function readVSCDBState() {
             try {
                 const escapedKey = key.replace(/'/g, "''");
                 const query = `SELECT value FROM ItemTable WHERE key='${escapedKey}'`;
-                const result = execSync(`sqlite3 "${VSCDB_PATH}" "${query}"`, {
+                const result = execSync(`sqlite3 "${actualPath}" "${query}"`, {
                     encoding: 'utf8',
                     stdio: ['ignore', 'pipe', 'pipe'],
                 }).trim();
@@ -649,7 +964,7 @@ function readVSCDBState() {
             try {
                 const escapedKey = key.replace(/'/g, "''");
                 const query = `SELECT value FROM ItemTable WHERE key='${escapedKey}'`;
-                const result = execSync(`sqlite3 "${VSCDB_PATH}" "${query}"`, {
+                const result = execSync(`sqlite3 "${actualPath}" "${query}"`, {
                     encoding: 'utf8',
                     stdio: ['ignore', 'pipe', 'pipe'],
                 }).trim();
@@ -677,6 +992,30 @@ function readVSCDBState() {
                 // Continue to next key
             }
         }
+        // Query for chat.tools data (for chat.tools.autoApprove setting)
+        const chatToolsKey = "chat.tools";
+        try {
+            const escapedKey = chatToolsKey.replace(/'/g, "''");
+            const query = `SELECT value FROM ItemTable WHERE key='${escapedKey}'`;
+            const result = execSync(`sqlite3 "${actualPath}" "${query}"`, {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            }).trim();
+            if (result && result !== '') {
+                try {
+                    const parsed = JSON.parse(result);
+                    if (parsed && typeof parsed === 'object') {
+                        stateData.chat = { tools: parsed };
+                    }
+                }
+                catch (parseError) {
+                    // Continue if parse fails
+                }
+            }
+        }
+        catch (error) {
+            // Continue if query fails
+        }
         // If we found composerState, also check if extensionsAssistant/extensions are nested within it
         if (stateData.composerState && typeof stateData.composerState === 'object') {
             const composerState = stateData.composerState;
@@ -689,7 +1028,7 @@ function readVSCDBState() {
                 stateData.extensions = composerState.extensions;
             }
         }
-        // Return the combined state data (composerState, extensionsAssistant, extensions)
+        // Return the combined state data (composerState, extensionsAssistant, extensions, chat, installedExtensions)
         // If we have any data, return it; otherwise return null
         if (Object.keys(stateData).length > 0) {
             return stateData;
@@ -701,6 +1040,37 @@ function readVSCDBState() {
         return null;
     }
 }
+/**
+ * Read installed extensions from Cursor extensions cache file.
+ * Original cache has: result[].identifier.id, result[].manifest.displayName, .version, .publisher.
+ * We collect publisher so UI can distinguish same displayName (e.g. "Python" from Microsoft vs Anysphere) later.
+ * Returns array: [{ id, displayName, version, publisher }, ...]
+ */
+function readInstalledExtensions() {
+    const extensions = [];
+    try {
+        if (!existsSync(EXTENSIONS_CACHE_PATH)) {
+            return extensions;
+        }
+        const content = readFileSync(EXTENSIONS_CACHE_PATH, 'utf-8');
+        const data = JSON.parse(content);
+        if (data.result && Array.isArray(data.result)) {
+            for (const ext of data.result) {
+                const id = ext.identifier?.id;
+                const displayName = ext.manifest?.displayName || ext.manifest?.publisher || '';
+                const version = ext.manifest?.version || '';
+                const publisher = ext.manifest?.publisher;
+                if (id) {
+                    extensions.push({ id, displayName, version, publisher });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error reading installed extensions from cache:`, error instanceof Error ? error.message : String(error));
+    }
+    return extensions;
+}
 /**
  * Collect all configuration files
  */
@@ -752,6 +1122,22 @@ function collectConfigFiles() {
                 },
             });
         }
+        // Store chat.tools as vscode_settings (for chat.tools.autoApprove policy)
+        // Send as separate file entry to match policy engine expectations
+        const chat = vscdbState.chat;
+        if (chat?.tools) {
+            configFiles.push({
+                file_type: 'vscode_settings',
+                file_path: `${VSCDB_PATH}#chat.tools`, // Use fragment to distinguish
+                raw_content: {
+                    chat: {
+                        tools: chat.tools,
+                    },
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                },
+            });
+        }
         // Store extensionsAssistant.recommendations as cursor_extensions
         // (same type as .vscode/extensions.json recommendations)
         // Structure must match evaluation plan path: extensionsAssistant.recommendations
@@ -786,6 +1172,23 @@ function collectConfigFiles() {
             });
         }
     }
+    // Store installed extensions as cursor_extensions
+    // Read from extensions cache file (more reliable than state.vscdb)
+    // Format: [{ id, displayName, version }, ...]
+    // This is collected separately from state.vscdb since it's in a different file
+    const installedExtensions = readInstalledExtensions();
+    if (installedExtensions.length > 0) {
+        console.log(`Found ${installedExtensions.length} installed extension(s) at: ${EXTENSIONS_CACHE_PATH}`);
+        configFiles.push({
+            file_type: 'cursor_extensions',
+            file_path: `${EXTENSIONS_CACHE_PATH}#installedExtensions`, // Use fragment to distinguish
+            raw_content: {
+                installedExtensions: installedExtensions,
+                source: 'extensions.user.cache',
+                extracted_at: new Date().toISOString(),
+            },
+        });
+    }
     // Read Claude configuration files (project root, local overrides, home directory)
     for (const { path, file_type } of CLAUDE_FILE_PATHS) {
         try {
@@ -1220,12 +1623,16 @@ async function sendConfigFile(configFile, hardwareUuid, authKey) {
         file_path: configFile.file_path,
         raw_content: configFile.raw_content,
     };
-    // Sign the payload
+    // Sign the payload (metadata is not part of signature)
     const signature = createSignature(payload, authKey.key);
     const body = {
         ...payload,
         signature,
         key_id: authKey.key_id || '',
+        metadata: {
+            org_identifier: process.env.GITHUB_ORG || process.env.GH_ORG || '',
+            repo_identifier: process.env.GITHUB_REPOSITORY || process.env.GH_REPOSITORY || '',
+        },
     };
     try {
         console.log(`Posting ${configFile.file_type} to: ${apiUrl}`);
@@ -1387,17 +1794,194 @@ async function ensureAuthentication(hardwareUuid) {
         throw new Error(`Failed to authenticate: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/**
+ * Determine file type from file path (matches backend logic)
+ */
+function determineFileTypeFromPath(filePath) {
+    if (!filePath) {
+        return null;
+    }
+    // Normalize path (handle both forward and backslashes)
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    // Pattern matching (order matters - most specific first)
+    // These patterns match the backend's file_type_detector.py
+    // MCP configs
+    if (normalizedPath.includes('/.cursor/mcp.json') ||
+        normalizedPath.includes('mcp.json') ||
+        normalizedPath.includes('.mcp.json')) {
+        return 'mcp_config';
+    }
+    // Claude settings (most specific first)
+    if (normalizedPath.includes('/Library/Application Support/ClaudeCode/managed-settings.json')) {
+        return 'claude_settings';
+    }
+    if (normalizedPath.includes('.claude/settings.local.json') ||
+        normalizedPath.includes('~/.claude/settings.local.json') ||
+        normalizedPath.includes('/.claude/settings.local.json')) {
+        return 'claude_settings';
+    }
+    if (normalizedPath.includes('.claude/settings.json') ||
+        normalizedPath.includes('~/.config/claude/settings.json') ||
+        normalizedPath.includes('/.config/claude/settings.json')) {
+        return 'claude_settings';
+    }
+    // Cursor hooks
+    if (normalizedPath.includes('.cursor/hooks.json') ||
+        normalizedPath.includes('/Library/Application Support/Cursor/hooks.json')) {
+        return 'cursor_hooks';
+    }
+    // Claude rule config
+    if (normalizedPath.includes('CLAUDE.md') || normalizedPath.includes('CLAUDE.local.md')) {
+        return 'claude_rule_config';
+    }
+    // Claude rules
+    if (normalizedPath.includes('.claude/rules/')) {
+        return 'claude_rule';
+    }
+    // Cursor rules
+    if (normalizedPath.includes('.cursor/rules/')) {
+        return 'cursor_rule';
+    }
+    // Cursor extensions
+    if (normalizedPath.includes('.vscode/extensions.json') ||
+        normalizedPath.includes('state.vscdb')) {
+        return 'cursor_extensions';
+    }
+    // Default: try to infer from path structure
+    if (normalizedPath.includes('.claude') && normalizedPath.endsWith('.json')) {
+        return 'claude_settings';
+    }
+    if (normalizedPath.includes('.cursor') && normalizedPath.endsWith('.json')) {
+        return 'cursor_hooks';
+    }
+    return null;
+}
+/**
+ * Log a single file by path
+ */
+async function logSingleFile(filePath) {
+    const hardwareUuid = resolveHardwareUuid();
+    // Ensure we have authentication
+    const authKey = await ensureAuthentication(hardwareUuid);
+    // Determine file type
+    let fileType = determineFileTypeFromPath(filePath);
+    // Read the file
+    let rawContent = null;
+    if (!existsSync(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        return false;
+    }
+    // Special handling for SQLite databases (state.vscdb)
+    // Check if this is the state.vscdb file (with or without fragment)
+    const isVSCDB = filePath.includes('state.vscdb');
+    if (isVSCDB) {
+        // Extract the actual file path (remove fragment if present)
+        const actualPath = filePath.split('#')[0];
+        // Read the SQLite database using the provided path
+        const vscdbState = readVSCDBState(actualPath);
+        if (vscdbState) {
+            // 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) {
+                rawContent = {
+                    composerState: vscdbState.composerState,
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                };
+                fileType = 'vscode_settings';
+            }
+            else if (fragment === 'chat.tools' && vscdbState.chat) {
+                rawContent = {
+                    chat: {
+                        tools: vscdbState.chat.tools,
+                    },
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                };
+                fileType = 'vscode_settings';
+            }
+            else if (!fragment && vscdbState.composerState) {
+                // No fragment specified, default to composerState
+                rawContent = {
+                    composerState: vscdbState.composerState,
+                    source: 'state.vscdb',
+                    extracted_at: new Date().toISOString(),
+                };
+                fileType = 'vscode_settings';
+            }
+            else {
+                console.error(`Could not extract ${fragment || 'data'} from state.vscdb`);
+                return false;
+            }
+        }
+        else {
+            console.error(`Could not read state.vscdb from ${actualPath}`);
+            return false;
+        }
+    }
+    else {
+        // Try reading as JSON first
+        rawContent = readJSONFile(filePath);
+        if (!rawContent) {
+            // Try reading as markdown/text
+            const markdownContent = readMarkdownFile(filePath);
+            if (markdownContent !== null) {
+                rawContent = {
+                    content: markdownContent,
+                    source: 'file',
+                };
+                // Infer file type from path if not determined
+                if (!fileType) {
+                    if (filePath.includes('CLAUDE.md') || filePath.includes('claude')) {
+                        fileType = 'claude_rule_config';
+                    }
+                    else if (filePath.includes('.cursor')) {
+                        fileType = 'cursor_rule';
+                    }
+                }
+            }
+        }
+    }
+    if (!rawContent) {
+        console.error(`Could not read file: ${filePath}`);
+        return false;
+    }
+    // If file type still not determined, default to claude_settings for JSON files
+    if (!fileType) {
+        if (filePath.includes('.claude') && filePath.endsWith('.json')) {
+            fileType = 'claude_settings';
+        }
+        else if (filePath.includes('.cursor') && filePath.endsWith('.json')) {
+            fileType = 'cursor_hooks';
+        }
+        else {
+            console.error(`Could not determine file type for: ${filePath}`);
+            return false;
+        }
+    }
+    const configFile = {
+        file_type: fileType,
+        file_path: filePath,
+        raw_content: rawContent,
+    };
+    return await sendConfigFile(configFile, hardwareUuid, authKey);
+}
 /**
  * Main execution
  */
 async function main() {
+    // Log all files (original behavior)
     const hardwareUuid = resolveHardwareUuid();
     console.log(`Hardware UUID: ${hardwareUuid}`);
     // Ensure we have authentication (do handshake if needed)
     const authKey = await ensureAuthentication(hardwareUuid);
     console.log('Authentication verified, proceeding with config file logging.');
-    // Collect all config files
-    const configFiles = collectConfigFiles();
+    // Prefer API-driven collection: call endpoint to get the complete list of what to look for
+    const endpointBase = loadEndpointBase();
+    const patternsResponse = await getFileCollectionPatterns(endpointBase);
+    const configFiles = patternsResponse?.patterns?.length
+        ? collectConfigFilesFromPatterns(patternsResponse.patterns, PROJECT_ROOT)
+        : collectConfigFiles();
     console.log(`Collected ${configFiles.length} configuration file(s).`);
     if (configFiles.length === 0) {
         console.log('No configuration files found to log.');
@@ -1422,4 +2006,4 @@ if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.includes
         process.exit(1);
     });
 }
-export { main, collectConfigFiles, ensureAuthentication, sendConfigFile, createSignature, canonicalizePayload, readVSCDBState };
+export { main, collectConfigFiles, collectConfigFilesFromPatterns, resolvePatternToTargets, ensureAuthentication, sendConfigFile, createSignature, canonicalizePayload, readVSCDBState, logSingleFile, };

package/package.json

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