log-llm-config 1.0.30 → 1.0.32

package/dist/endpoint_client/startup_api.js

@@ -1,10 +1,7 @@
 import { executeBody } from './http_transport.js';
 export const postStartupPayload = async (endpointUrl, body, timeoutMs = 5000) => {
     const payload = JSON.stringify(body);
-    console.log('Sending payload to endpoint:', endpointUrl, payload);
-    const { statusCode, statusMessage, headers, body: responseBody } = await executeBody(endpointUrl, 'POST', payload, timeoutMs);
-    console.log(`HTTP ${statusCode} ${statusMessage}`);
-    console.log('Response headers:', headers);
+    const { statusCode, statusMessage, body: responseBody } = await executeBody(endpointUrl, 'POST', payload, timeoutMs);
     if (statusCode >= 400) {
         const msg = statusCode === 413
             ? `413 Request Entity Too Large: ${responseBody.substring(0, 200)}`
@@ -13,7 +10,6 @@ export const postStartupPayload = async (endpointUrl, body, timeoutMs = 5000) =>
     }
     if (!responseBody)
         return { status: 'error', message: 'Empty response from endpoint' };
-    console.log('Raw endpoint response body:', responseBody);
     try {
         return JSON.parse(responseBody);
     }

package/dist/log_config_files/collection/config_collector.js

@@ -1,10 +1,11 @@
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { readJSONFile, readMCPConfig, readMarkdownFile, readInstalledExtensions } from '../readers/file_readers.js';
 import { getExtensionsCachePath, getExtensionsCacheInstalledSuffix, getVscdbPath } from '../paths/path_constants_helpers.js';
 import { resolvePatternToTargets, normalizePathSkipPrefixes } from '../paths/pattern_resolver.js';
 import { enrichRawFromRecipe } from './enrichment_helpers.js';
-import { collectDirectoryEntries } from './directory_collector.js';
+import { collectDirectoryEntries, collectDirectoryMetadata } from './directory_collector.js';
 import { collectVscdbEntries } from '../readers/vscdb_config_builder.js';
 import { pushDerivedFilesFromRecipe } from './openclaw_helpers.js';
 function buildCollectionContext(patterns, projectRoot, home, homeRecurseSkipDirs = [], absolutePathPrefixes = [], mcpToolGlobSpec = null, clientPathConstants = null, pathResolutionSpecs = null) {
@@ -46,9 +47,18 @@ function readContentByFormat(path, format) {
 }
 function collectRegularFileEntry(t, enrichByFileType) {
     const format = t.content_format || 'json';
-    const content = readContentByFormat(t.path, format);
+    let content = readContentByFormat(t.path, format);
     if (content === null)
         return null;
+    // For JSON-format files, backend/policy engine expect raw_content to be the parsed object (e.g. permissions.allow)
+    if (format === 'json' && typeof content === 'string') {
+        try {
+            content = JSON.parse(content);
+        }
+        catch {
+            // leave as string if parse fails
+        }
+    }
     let raw;
     if (t.raw_key && typeof content === 'string') {
         raw = { [t.raw_key]: content };
@@ -81,7 +91,20 @@ function handleInstalledExtensions(handledSpecialPaths, configFiles, extensionsC
         configFiles.push({ file_type: 'cursor_extensions', file_path: `${extensionsCachePath}${suffix}`, raw_content: { installedExtensions: installed, source: 'extensions.user.cache', extracted_at: new Date().toISOString() } });
 }
 function collectConfigFilesFromPatterns(patterns, projectRoot, onProgress, options) {
-    const home = homedir();
+    // Prefer process.env.HOME so hook invoker (e.g. Cursor) can pass real home when it differs from os.homedir()
+    const home = (process.env.HOME && process.env.HOME.trim()) || homedir();
+    try {
+        const claudeSettingsPath = join(home, '.claude', 'settings.json');
+        writeFileSync(join(process.cwd(), '.optimus-home-debug.json'), JSON.stringify({
+            process_env_HOME: process.env.HOME ?? null,
+            homedir: homedir(),
+            resolved_home: home,
+            claude_settings_path: claudeSettingsPath,
+            claude_settings_exists: existsSync(claudeSettingsPath),
+            cwd: process.cwd(),
+        }, null, 2));
+    }
+    catch (_) { }
     const pathConstants = options?.client_path_constants;
     if (!pathConstants)
         throw new Error('client_path_constants required from API response but not provided');
@@ -101,7 +124,14 @@ function collectConfigFilesFromPatterns(patterns, projectRoot, onProgress, optio
             onProgress(`scanning file_type=${t.file_type}`);
         }
         if (t.isDirectory) {
-            configFiles.push(...collectDirectoryEntries(t));
+            if (metadataOnlyFileTypes.has(t.file_type) || t.collect_style === 'metadata') {
+                const entry = collectDirectoryMetadata(t);
+                if (entry)
+                    configFiles.push(entry);
+            }
+            else {
+                configFiles.push(...collectDirectoryEntries(t));
+            }
             continue;
         }
         if (extensionsInstalledSuffix && t.path.includes(extensionsInstalledSuffix)) {

package/dist/log_config_files/collection/directory_collector.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJSONFile, readMarkdownFile } from '../readers/file_readers.js';
 function collectSubdirMdFiles(dirPath, fileType, mdFilename, source) {
@@ -32,7 +32,10 @@ function collectDirectoryEntries(t) {
             if (!entry.isFile() || !matchName(entry.name))
                 continue;
             const fullPath = join(t.path, entry.name);
-            const content = readMarkdownFile(fullPath) ?? readJSONFile(fullPath);
+            // Prefer parsed JSON for .json files so backend/policy engine see top-level keys (e.g. permissions.allow)
+            const content = entry.name.endsWith('.json')
+                ? readJSONFile(fullPath) ?? readMarkdownFile(fullPath)
+                : readMarkdownFile(fullPath) ?? readJSONFile(fullPath);
             if (content !== null) {
                 const raw = typeof content === 'string' ? { content, source: 'file' } : content;
                 results.push({ file_type: t.file_type, file_path: fullPath, raw_content: raw });
@@ -47,4 +50,47 @@ function collectDirectoryEntries(t) {
     }
     return results;
 }
-export { collectDirectoryEntries };
+/**
+ * For metadata-style DIR targets: scan files matching dir_glob, return one entry
+ * with the highest mtime found. Falls back to the directory's own mtime if no files match.
+ */
+function collectDirectoryMetadata(t) {
+    try {
+        const dirStat = statSync(t.path);
+        let bestMtime = dirStat.mtime;
+        let bestPath = t.path;
+        const glob = t.dir_glob ?? '*';
+        const matchName = (name) => {
+            if (glob === '*')
+                return true;
+            if (glob.startsWith('*.'))
+                return name.endsWith(glob.slice(1));
+            return name === glob;
+        };
+        try {
+            for (const entry of readdirSync(t.path, { withFileTypes: true })) {
+                if (!entry.isFile() || !matchName(entry.name))
+                    continue;
+                try {
+                    const fileStat = statSync(join(t.path, entry.name));
+                    if (fileStat.mtime > bestMtime) {
+                        bestMtime = fileStat.mtime;
+                        bestPath = join(t.path, entry.name);
+                    }
+                }
+                catch { /* ignore unreadable files */ }
+            }
+        }
+        catch { /* ignore unreadable dir */ }
+        return {
+            file_type: t.file_type,
+            file_path: bestPath,
+            raw_content: { filename: bestPath, last_modified: bestMtime.toISOString(), source: 'file_metadata' },
+            collect_style: 'metadata',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export { collectDirectoryEntries, collectDirectoryMetadata };

package/dist/log_config_files/paths/pattern_resolver.js

@@ -60,17 +60,27 @@ function expandGlobPathPattern(pathPattern, fileType, home, projectRoot, content
         return targets;
     const isDir = norm.endsWith('/');
     const [before, after] = norm.split('*');
-    const beforeNorm = before.replace(/\/+$/, '');
     const afterNorm = after.replace(/^\/+/, '');
+    // If `before` doesn't end with '/', the * is mid-segment (e.g. "extensions/saoudrizwan.claude-dev*/" →
+    // parent="extensions/", namePrefix="saoudrizwan.claude-dev"). Split on last '/' to get the real base dir.
+    let parentPart = before.replace(/\/+$/, '');
+    let namePrefix = '';
+    if (!before.endsWith('/')) {
+        const lastSlash = parentPart.lastIndexOf('/');
+        if (lastSlash !== -1) {
+            namePrefix = parentPart.slice(lastSlash + 1);
+            parentPart = parentPart.slice(0, lastSlash);
+        }
+    }
     let basePath;
-    if (beforeNorm.startsWith('~/')) {
-        basePath = join(home, beforeNorm.slice(2));
+    if (parentPart.startsWith('~/')) {
+        basePath = join(home, parentPart.slice(2));
     }
-    else if (beforeNorm.startsWith('/') && absolutePathPrefixes.some((prefix) => beforeNorm.startsWith(prefix))) {
-        basePath = beforeNorm;
+    else if (parentPart.startsWith('/') && absolutePathPrefixes.some((prefix) => parentPart.startsWith(prefix))) {
+        basePath = parentPart;
     }
     else {
-        basePath = join(projectRoot, beforeNorm.startsWith('/') ? beforeNorm.slice(1) : beforeNorm);
+        basePath = join(projectRoot, parentPart.startsWith('/') ? parentPart.slice(1) : parentPart);
     }
     if (!existsSync(basePath))
         return targets;
@@ -78,6 +88,8 @@ function expandGlobPathPattern(pathPattern, fileType, home, projectRoot, content
         for (const entry of readdirSync(basePath, { withFileTypes: true })) {
             if (!entry.isDirectory())
                 continue;
+            if (namePrefix && !entry.name.startsWith(namePrefix))
+                continue;
             const resolvedPath = join(basePath, entry.name, afterNorm);
             if (!existsSync(resolvedPath))
                 continue;

package/dist/log_config_files/runtime/main_runner.js

@@ -118,6 +118,11 @@ async function main() {
     const collectMs = Date.now() - collectStartMs;
     const fileTypes = [...new Set(configFiles.map((c) => c.file_type))].join(', ');
     hookRunLog(`collected ${configFiles.length} config file(s) collect_ms=${collectMs} file_types=${fileTypes}`);
+    const claudeSettings = configFiles.filter((c) => c.file_type === 'claude_settings');
+    if (claudeSettings.length > 0)
+        hookRunLog(`claude_settings in batch: ${claudeSettings.length} path(s): ${claudeSettings.map((c) => c.file_path).join(', ')}`);
+    else
+        hookRunLog(`claude_settings in batch: 0 (none collected)`);
     if (configFiles.length === 0) {
         hookRunLog('no config files found, exiting');
         process.exit(0);

package/dist/log_config_files/sender/batch_sender.js

@@ -103,13 +103,6 @@ async function sendConfigFilesBatch(configFiles, hardwareUuid, authKey, hookRequ
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             hookRunLog(`batch chunk error: ${errorMessage}`);
-            const is413 = errorMessage.includes('413') || errorMessage.includes('Request Entity Too Large') || errorMessage.includes('Entity Too Large');
-            if (is413 && chunk.length > 1) {
-                hookRunLog(`413 error, splitting ${chunk.length} files`);
-                splitChunk(chunks, chunkIndex);
-                // Don't increment — retry with the smaller first half
-                continue;
-            }
             totals.failed += chunk.length;
         }
         chunkIndex++;

package/dist/log_config_files/sender/signing.js

@@ -1,27 +1,15 @@
 import crypto from 'node:crypto';
-/** Recursively sort object keys to produce a canonical representation. */
-function canonicalizeValue(value) {
-    if (Array.isArray(value)) {
-        return value.map(canonicalizeValue);
-    }
-    if (value && typeof value === 'object') {
-        const sortedKeys = Object.keys(value).sort();
-        const result = {};
-        for (const key of sortedKeys) {
-            result[key] = canonicalizeValue(value[key]);
-        }
-        return result;
-    }
-    return value;
-}
-/** Canonicalize payload (sort keys, compact JSON) to match server. */
+import { createRequire } from 'node:module';
+const canonicalize = createRequire(import.meta.url)('canonicalize');
+/** RFC 8785 canonical JSON — must match server's rfc8785.dumps() exactly. */
 function canonicalizePayload(payload) {
-    return JSON.stringify(canonicalizeValue(payload));
+    const out = canonicalize(payload);
+    return out ?? '{}';
 }
-/** Create HMAC-SHA256 signature for a payload. */
+/** Create HMAC-SHA256 signature for a payload (canonicalize then sign). */
 function createSignature(payload, keyHex) {
     const canonicalPayload = canonicalizePayload(payload);
     const keyBuffer = Buffer.from(keyHex, 'hex');
     return crypto.createHmac('sha256', keyBuffer).update(canonicalPayload).digest('hex');
 }
-export { canonicalizeValue, canonicalizePayload, createSignature };
+export { canonicalizePayload, createSignature };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "log-llm-config",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {
@@ -49,6 +49,7 @@
     "vitest": "^4.0.15"
   },
   "dependencies": {
-    "axios": "^1.7.9"
+    "axios": "^1.7.9",
+    "canonicalize": "^2.1.0"
   }
-}
+}