log-llm-config-staging 1.3.96 → 1.3.98

package/dist/log_config_files/collection/config_collector.js

@@ -7,6 +7,7 @@ import { enrichRawFromRecipe } from './enrichment_helpers.js';
 import { collectDirectoryEntries, collectDirectoryMetadata } from './directory_collector.js';
 import { collectVscdbEntries } from '../readers/vscdb_config_builder.js';
 import { pushDerivedFilesFromRecipe } from './openclaw_helpers.js';
+import { collapseMetadataByFileType } from './metadata_merge.js';
 function buildCollectionContext(patterns, projectRoot, home, homeRecurseSkipDirs = [], absolutePathPrefixes = [], mcpToolGlobSpec = null, clientPathConstants = null, pathResolutionSpecs = null) {
     const seenPaths = new Set();
     const targets = [];
@@ -148,7 +149,7 @@ function collectConfigFilesFromPatterns(patterns, projectRoot, onProgress, optio
                 pushDerivedFilesFromRecipe(entry.raw_content, configFiles, recipe);
         }
     }
-    return configFiles;
+    return collapseMetadataByFileType(configFiles);
 }
 // ─── Re-exports (barrel for public API) ──────────────────────────────────────
 export { collectConfigFilesFromPatterns };

package/dist/log_config_files/collection/directory_collector.js

@@ -57,6 +57,8 @@ function matchesDirGlob(name, glob) {
     // **/*.jsonl → match any extension suffix after **/
     if (glob.startsWith('**/')) {
         const suffix = glob.slice(3);
+        if (suffix === '*' || suffix === '**')
+            return true;
         if (suffix.startsWith('*.'))
             return name.endsWith(suffix.slice(1));
         return name === suffix;

package/dist/log_config_files/collection/metadata_merge.js

@@ -0,0 +1,43 @@
+/** When several install/log paths exist for one agent, keep a single metadata row (newest mtime). */
+const METADATA_COLLAPSE_BY_FILE_TYPE = new Set(['opencode_presence', 'opencode_log']);
+function metadataLastModifiedMs(entry) {
+    const raw = entry.raw_content;
+    if (!raw || typeof raw !== 'object')
+        return 0;
+    const lm = raw.last_modified;
+    if (typeof lm !== 'string')
+        return 0;
+    const ms = Date.parse(lm);
+    return Number.isFinite(ms) ? ms : 0;
+}
+/**
+ * Collapse multiple metadata uploads of the same file_type to one row: highest last_modified wins.
+ */
+function collapseMetadataByFileType(files) {
+    const passthrough = [];
+    const groups = new Map();
+    for (const f of files) {
+        if (f.collect_style === 'metadata' && METADATA_COLLAPSE_BY_FILE_TYPE.has(f.file_type)) {
+            const list = groups.get(f.file_type) ?? [];
+            list.push(f);
+            groups.set(f.file_type, list);
+        }
+        else {
+            passthrough.push(f);
+        }
+    }
+    const merged = [...passthrough];
+    for (const [, list] of groups) {
+        if (list.length === 0)
+            continue;
+        let best = list[0];
+        for (let i = 1; i < list.length; i++) {
+            if (metadataLastModifiedMs(list[i]) > metadataLastModifiedMs(best)) {
+                best = list[i];
+            }
+        }
+        merged.push(best);
+    }
+    return merged;
+}
+export { collapseMetadataByFileType, METADATA_COLLAPSE_BY_FILE_TYPE };

package/dist/log_config_files/paths/pattern_resolver.js

@@ -54,24 +54,18 @@ function expandRecursiveGlobPathPattern(pathPattern, fileType, home, contentForm
 }
 function expandGlobPathPattern(pathPattern, fileType, home, projectRoot, contentFormat, dirGlob, absolutePathPrefixes = []) {
     const norm = pathPattern.replace(/\\/g, '/');
-    const targets = [];
-    const asteriskIndex = norm.indexOf('*');
-    if (asteriskIndex === -1)
-        return targets;
+    if (!norm.includes('*'))
+        return [];
+    // `**` is the recursive-glob sigil handled by expandRecursiveGlobPathPattern.
+    if (norm.includes('**'))
+        return [];
     const isDir = norm.endsWith('/');
-    const [before, after] = norm.split('*');
-    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);
-        }
-    }
+    // Resolve the literal prefix that ends before the first wildcard segment.
+    const firstStarIndex = norm.indexOf('*');
+    const lastSlashBeforeStar = norm.lastIndexOf('/', firstStarIndex);
+    if (lastSlashBeforeStar === -1)
+        return [];
+    const parentPart = norm.slice(0, lastSlashBeforeStar);
     let basePath;
     if (parentPart.startsWith('~/')) {
         basePath = join(home, parentPart.slice(2));
@@ -83,20 +77,61 @@ function expandGlobPathPattern(pathPattern, fileType, home, projectRoot, content
         basePath = join(projectRoot, parentPart.startsWith('/') ? parentPart.slice(1) : parentPart);
     }
     if (!existsSync(basePath))
-        return targets;
-    try {
-        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;
-            targets.push({ path: resolvedPath, file_type: fileType, isDirectory: isDir, dir_glob: dirGlob, content_format: contentFormat });
+        return [];
+    // Walk remaining segments. Each segment may be a bare wildcard '*' (matches
+    // any single directory), a prefix/suffix wildcard like 'foo*' or 'foo*bar',
+    // or a literal name. Recursion correctly handles multi-wildcard patterns
+    // such as ``*/*/cowork_plugins/marketplaces/*/.claude-plugin/marketplace.json``
+    // — the prior single-split implementation only expanded the first wildcard
+    // and silently pushed a partial directory path as the target, which then
+    // surfaced as EISDIR when downstream collectors tried to read it as a file.
+    const remaining = norm.slice(lastSlashBeforeStar + 1);
+    const segments = remaining.split('/').filter((s) => s !== '');
+    const targets = [];
+    function recurse(currentPath, segIdx) {
+        if (segIdx === segments.length) {
+            if (!existsSync(currentPath))
+                return;
+            targets.push({ path: currentPath, file_type: fileType, isDirectory: isDir, dir_glob: dirGlob, content_format: contentFormat });
+            return;
+        }
+        const seg = segments[segIdx];
+        if (seg === '*') {
+            if (!existsSync(currentPath))
+                return;
+            try {
+                for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    recurse(join(currentPath, entry.name), segIdx + 1);
+                }
+            }
+            catch { /* ignore read errors */ }
+        }
+        else if (seg.includes('*')) {
+            const wildcardIdx = seg.indexOf('*');
+            const prefix = seg.slice(0, wildcardIdx);
+            const suffix = seg.slice(wildcardIdx + 1);
+            if (!existsSync(currentPath))
+                return;
+            try {
+                for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    if (prefix && !entry.name.startsWith(prefix))
+                        continue;
+                    if (suffix && !entry.name.endsWith(suffix))
+                        continue;
+                    recurse(join(currentPath, entry.name), segIdx + 1);
+                }
+            }
+            catch { /* ignore read errors */ }
+        }
+        else {
+            recurse(join(currentPath, seg), segIdx + 1);
         }
     }
-    catch { /* ignore read errors */ }
+    recurse(basePath, 0);
     return targets;
 }
 /**

package/dist/log_config_files/runtime/compliance_check.js

@@ -41,6 +41,8 @@ export function normalizeAgentToken(raw) {
         return 'cursor';
     if (s === 'copilot')
         return 'copilot';
+    if (s === 'opencode')
+        return 'opencode';
     return '';
 }
 function currentAgentFromEnv() {
@@ -48,12 +50,14 @@ function currentAgentFromEnv() {
     const override = normalizeAgentToken(process.env.OPTIMUS_AGENT);
     if (override)
         return override;
-    // Backwards-compatible: hook wrappers set OPTIMUS_HOOK_TYPE to cursor|claude|copilot.
+    // Backwards-compatible: hook wrappers set OPTIMUS_HOOK_TYPE to cursor|claude|copilot|opencode.
     const hookType = normalizeAgentToken(process.env.OPTIMUS_HOOK_TYPE);
     if (hookType === 'cursor')
         return 'cursor';
     if (hookType === 'copilot')
         return 'copilot';
+    if (hookType === 'opencode')
+        return 'opencode';
     return 'claude';
 }
 function targetsCurrentAgent(entry, agent) {

package/dist/log_config_files/runtime/hook_type_for_request.js

@@ -0,0 +1,28 @@
+function normalizeToken(raw) {
+    if (!raw?.trim())
+        return '';
+    const s = raw.trim().toLowerCase().replace(/-/g, '_');
+    if (s === 'claude_desktop')
+        return 'claude';
+    if (s === 'github_copilot')
+        return 'copilot';
+    if (s === 'cursor' || s === 'claude' || s === 'copilot' || s === 'opencode')
+        return s;
+    // Legacy hooks set OPTIMUS_AGENT=Cursor (display casing)
+    if (raw.trim() === 'Cursor')
+        return 'cursor';
+    return s;
+}
+/** Resolve hook_request.hook_type from hook wrapper env (OPTIMUS_HOOK_TYPE, then OPTIMUS_AGENT). */
+export function resolveHookTypeFromEnv(env = process.env) {
+    const fromHook = normalizeToken(env.OPTIMUS_HOOK_TYPE);
+    const fromAgent = normalizeToken(env.OPTIMUS_AGENT);
+    const token = fromHook || fromAgent || 'claude';
+    if (token === 'cursor')
+        return 'cursor';
+    if (token === 'copilot')
+        return 'copilot';
+    if (token === 'opencode')
+        return 'opencode';
+    return 'claude';
+}

package/dist/log_config_files/runtime/main_runner.js

@@ -7,6 +7,7 @@ import { OPT_AI_SEC_MANAGEMENT_REL } from '../../bootstrap_constants.js';
 import { runSensitivePathsAudit } from '../../log_sensitive_paths_audit.js';
 import { loadEndpointBase, getEndpointSource } from '../sender/endpoint_config.js';
 import { hookLogReplace, hookRunLog } from './hook_logger.js';
+import { resolveHookTypeFromEnv } from './hook_type_for_request.js';
 import { resolveHardwareUuid } from './hardware_uuid.js';
 import { ensureAuthentication } from '../auth/auth_flow.js';
 import { readJSONFile, readMarkdownFile } from '../readers/file_readers.js';
@@ -128,8 +129,7 @@ async function addSensitivePathsAudit(endpointBase, configFiles) {
     }
 }
 async function sendAllConfigFiles(configFiles, worktreeReport, hardwareUuid, authKey) {
-    const hookTypeRaw = (process.env.OPTIMUS_HOOK_TYPE || 'claude').toLowerCase();
-    const hookType = hookTypeRaw === 'cursor' ? 'cursor' : hookTypeRaw === 'copilot' ? 'copilot' : 'claude';
+    const hookType = resolveHookTypeFromEnv();
     const manifest = configFiles.map((c) => canonicalCursorUserStateVscdbPath(c.file_path));
     const workspaceRepo = ensureWorkspaceRepoEnv(manifest);
     const hookRequestId = await sendHookRequestCreate(hardwareUuid, authKey, hookType, workspaceRepo);

package/dist/log_config_files/runtime/trusted_restarts.js

@@ -34,6 +34,8 @@ function currentAgentFromEnv() {
         return 'cursor';
     if (override === 'copilot')
         return 'copilot';
+    if (override === 'opencode')
+        return 'opencode';
     if (override === 'claude' || override === 'claude_desktop')
         return 'claude';
     const hookType = normalizeAgentToken(process.env.OPTIMUS_HOOK_TYPE);
@@ -41,6 +43,8 @@ function currentAgentFromEnv() {
         return 'cursor';
     if (hookType === 'copilot')
         return 'copilot';
+    if (hookType === 'opencode')
+        return 'opencode';
     return 'claude';
 }
 /** Spawn each trusted command detached (same pattern as former compliance_prompt_gate fireRestartCommands). */

package/package.json

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