log-llm-config 1.3.97 → 1.4.8

package/dist/log_config_files/collection/skills_cli_collector.js

@@ -0,0 +1,146 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, mkdtempSync, openSync, readFileSync, rmSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const SKILLS_CLI_FILE_TYPE = 'skills_cli_installed';
+export const SKILLS_CLI_INSTALLED_PATH = join(homedir(), '.agents', '.skills-cli-installed.json');
+/** Override the skills package spec, e.g. `skills@1.5.10`. Default uses whatever is on the machine. */
+export const SKILLS_CLI_NPX_PACKAGE_ENV = 'SKILLS_CLI_NPX_PACKAGE';
+const LIST_TIMEOUT_MS = 120_000;
+/** stderr from npx/npm only; stdout is streamed to a temp file (avoids pipe/maxBuffer truncation). */
+const LIST_STDERR_MAX_BUFFER = 16 * 1024 * 1024;
+function listExecEnv() {
+    return {
+        ...process.env,
+        DISABLE_TELEMETRY: process.env.DISABLE_TELEMETRY ?? '1',
+    };
+}
+function npxPackageSpec() {
+    const fromEnv = (process.env[SKILLS_CLI_NPX_PACKAGE_ENV] || '').trim();
+    return fromEnv || 'skills';
+}
+/** Strip leading npx/npm noise and parse the skills `list --json` array payload. */
+export function parseSkillsListJsonStdout(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return [];
+    const start = trimmed.indexOf('[');
+    if (start < 0) {
+        throw new SyntaxError('skills list --json: no JSON array in stdout');
+    }
+    let end = trimmed.lastIndexOf(']');
+    let lastErr;
+    while (end > start) {
+        const slice = trimmed.slice(start, end + 1);
+        try {
+            const parsed = JSON.parse(slice);
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed;
+        }
+        catch (err) {
+            lastErr = err instanceof SyntaxError ? err : new SyntaxError(String(err));
+            end = trimmed.lastIndexOf(']', end - 1);
+        }
+    }
+    throw lastErr ?? new SyntaxError('skills list --json: could not parse stdout');
+}
+export function runSkillsListJson(args, cwd) {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'optimus-skills-list-'));
+    const outPath = join(tmpDir, 'stdout.json');
+    const outFd = openSync(outPath, 'w');
+    try {
+        const child = spawnSync('npx', [npxPackageSpec(), 'list', ...args, '--json'], {
+            cwd,
+            timeout: LIST_TIMEOUT_MS,
+            env: listExecEnv(),
+            stdio: ['ignore', outFd, 'pipe'],
+            maxBuffer: LIST_STDERR_MAX_BUFFER,
+        });
+        if (child.error)
+            throw child.error;
+        if (child.status !== 0) {
+            const stderr = (child.stderr ?? '').toString().trim();
+            throw new Error(stderr || `npx skills list exited ${child.status ?? 'unknown'}`);
+        }
+    }
+    finally {
+        closeSync(outFd);
+    }
+    try {
+        const out = readFileSync(outPath, 'utf8');
+        return parseSkillsListJsonStdout(out);
+    }
+    finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+function normalizeListRows(rows, scope) {
+    const out = [];
+    for (const row of rows) {
+        const name = (row.name || '').trim();
+        const path = (row.path || '').trim();
+        if (!name || !path)
+            continue;
+        const agents = Array.isArray(row.agents)
+            ? row.agents.map((a) => String(a).trim()).filter(Boolean)
+            : [];
+        out.push({
+            name,
+            path,
+            scope: (row.scope || scope).trim() || scope,
+            agents,
+        });
+    }
+    return out;
+}
+/** One-line-per-scope summary for hook_request.log (matches `skills list --json`). */
+export function formatSkillsListScopeForHookLog(scopeLabel, entries) {
+    if (entries.length === 0) {
+        return `skills_cli list ${scopeLabel}: 0 skill(s)`;
+    }
+    const detail = entries
+        .map((e) => `${e.name}@${e.path} agents=${e.agents.length ? e.agents.join(',') : 'none'}`)
+        .join(' | ');
+    return `skills_cli list ${scopeLabel}: ${entries.length} skill(s) — ${detail}`;
+}
+function runSkillsListForScope(scopeLabel, args, projectRoot, logLine) {
+    try {
+        return runSkillsListJson(args, projectRoot);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logLine(`skills_cli: list ${scopeLabel} --json failed: ${msg}`);
+        return [];
+    }
+}
+export function collectSkillsCliInstalled(projectRoot, log) {
+    const logLine = (message) => {
+        log?.(message);
+    };
+    const packageSpec = npxPackageSpec();
+    logLine(`skills_cli: npx ${packageSpec} — list -g --json && list --json (projectRoot=${projectRoot})`);
+    const globalRows = runSkillsListForScope('-g', ['-g'], projectRoot, logLine);
+    const projectRows = runSkillsListForScope('project', [], projectRoot, logLine);
+    const global = normalizeListRows(globalRows, 'global');
+    const project = normalizeListRows(projectRows, 'project');
+    logLine(formatSkillsListScopeForHookLog('-g', global));
+    logLine(formatSkillsListScopeForHookLog('project', project));
+    const payload = {
+        version: 1,
+        skills_cli_version: packageSpec,
+        generated_at: new Date().toISOString(),
+        global,
+        project,
+    };
+    if (payload.global.length === 0 && payload.project.length === 0) {
+        logLine('skills_cli_installed: not uploaded (no global or project skills)');
+        return null;
+    }
+    logLine(`skills_cli_installed: upload ${SKILLS_CLI_INSTALLED_PATH} global=${global.length} project=${project.length}`);
+    return {
+        file_type: SKILLS_CLI_FILE_TYPE,
+        file_path: SKILLS_CLI_INSTALLED_PATH,
+        raw_content: payload,
+    };
+}

package/dist/log_config_files/paths/pattern_resolver.js

@@ -8,6 +8,20 @@ function normalizePathSkipPrefixes(prefixes) {
         return [];
     return prefixes.filter((p) => typeof p === 'string' && p.length > 0);
 }
+/**
+ * Expands glob patterns containing double-asterisk (recursive directory traversal).
+ *
+ * Example: ~/.cursor/plugins/cache/ ** /skills/ recursively finds all skills
+ * directories under the cache folder, up to RECURSIVE_GLOB_MAX_DEPTH.
+ *
+ * @param pathPattern - Glob pattern with double-asterisk for recursive descent
+ * @param fileType - File type classification for collected targets
+ * @param home - User home directory path
+ * @param contentFormat - Optional content format hint
+ * @param dirGlob - Optional directory glob pattern
+ * @param homeRecurseSkipDirs - Directory names to skip when recursing from home
+ * @returns Array of collection targets matching the pattern
+ */
 function expandRecursiveGlobPathPattern(pathPattern, fileType, home, contentFormat, dirGlob, homeRecurseSkipDirs = []) {
     const norm = pathPattern.replace(/\\/g, '/');
     const doubleStarIndex = norm.indexOf('**');
@@ -25,7 +39,9 @@ function expandRecursiveGlobPathPattern(pathPattern, fileType, home, contentForm
         return [];
     }
     const targets = [];
-    const parts = after.split('/');
+    const parts = after.split('/').filter((s) => s.length > 0);
+    if (parts.length === 0)
+        return [];
     const dirName = parts[0];
     const fileName = parts.length > 1 ? parts[parts.length - 1] : null;
     const skipSet = homeRecurseSkipDirs.length ? new Set(homeRecurseSkipDirs) : new Set();
@@ -41,8 +57,21 @@ function expandRecursiveGlobPathPattern(pathPattern, fileType, home, contentForm
                     continue;
                 if (entry.name === dirName) {
                     const filePath = parts.length === 1 ? full : join(full, ...parts.slice(1));
-                    if (fileName && existsSync(filePath))
+                    if (parts.length === 1) {
+                        // e.g. ~/.cursor/plugins/cache/**/skills/ — collect each matched skills/ tree as a directory target
+                        if (existsSync(filePath)) {
+                            targets.push({
+                                path: filePath,
+                                file_type: fileType,
+                                isDirectory: true,
+                                content_format: contentFormat,
+                                dir_glob: dirGlob,
+                            });
+                        }
+                    }
+                    else if (fileName && existsSync(filePath)) {
                         targets.push({ path: filePath, file_type: fileType, content_format: contentFormat });
+                    }
                 }
                 walk(full, depth + 1, false);
             }
@@ -52,26 +81,43 @@ function expandRecursiveGlobPathPattern(pathPattern, fileType, home, contentForm
     walk(basePath, 0, true);
     return targets;
 }
+/**
+ * Expands glob patterns with asterisk wildcards (non-recursive) into concrete file or directory paths.
+ *
+ * Supports multi-segment wildcards (e.g., star-slash-star-slash patterns).
+ *
+ * **Key behavior:** On the final segment of a file pattern (not ending in slash), wildcards match
+ * files; earlier segments—and directory patterns—match directories only. This allows filename
+ * patterns like local_STAR.json to correctly resolve files rather than directories.
+ *
+ * Examples:
+ * - Pattern ending with a literal filename matches that file in wildcard directories
+ * - Pattern ending with prefix_STAR.ext matches files with that prefix and extension
+ * - Pattern ending with slash matches only directories
+ *
+ * @param pathPattern - Glob pattern (may not contain double-asterisk; use expandRecursiveGlobPathPattern for that)
+ * @param fileType - File type classification for collected targets
+ * @param home - User home directory path
+ * @param projectRoot - Project root directory path
+ * @param contentFormat - Optional content format hint
+ * @param dirGlob - Optional directory glob pattern
+ * @param absolutePathPrefixes - Allowed absolute path prefixes
+ * @returns Array of collection targets matching the pattern
+ */
 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 +129,65 @@ 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];
+        // On the final segment of a file pattern (not ending in `/`) wildcards
+        // match files; earlier segments — and dir patterns — match directories.
+        const wantFile = segIdx === segments.length - 1 && !isDir;
+        const entryMatches = (entry) => wantFile ? entry.isFile() : entry.isDirectory();
+        if (seg === '*') {
+            if (!existsSync(currentPath))
+                return;
+            try {
+                for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+                    if (!entryMatches(entry))
+                        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 (!entryMatches(entry))
+                        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/readers/file_readers.js

@@ -1,10 +1,120 @@
 import { existsSync, readFileSync } from 'node:fs';
+function stripJsoncComments(input) {
+    let out = '';
+    let inString = false;
+    let quote = '';
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i];
+        const next = i + 1 < input.length ? input[i + 1] : '';
+        if (inLineComment) {
+            if (ch === '\n') {
+                inLineComment = false;
+                out += ch;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === quote) {
+                inString = false;
+                quote = '';
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            quote = ch;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function stripTrailingCommas(input) {
+    let out = '';
+    let inString = false;
+    let quote = '';
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i];
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === quote) {
+                inString = false;
+                quote = '';
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            quote = ch;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            let j = i + 1;
+            while (j < input.length && /\s/.test(input[j]))
+                j += 1;
+            if (j < input.length && (input[j] === '}' || input[j] === ']'))
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function parseJsonWithJsoncFallback(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        try {
+            const sanitized = stripTrailingCommas(stripJsoncComments(raw));
+            return JSON.parse(sanitized);
+        }
+        catch {
+            return null;
+        }
+    }
+}
 /** Read and parse an MCP config file. Returns null on any error. */
 function readMCPConfig(filePath) {
     try {
         if (!existsSync(filePath))
             return null;
-        return JSON.parse(readFileSync(filePath, 'utf-8'));
+        return parseJsonWithJsoncFallback(readFileSync(filePath, 'utf-8'));
     }
     catch (error) {
         console.error(`Error reading ${filePath}:`, error instanceof Error ? error.message : String(error));
@@ -16,7 +126,7 @@ function readJSONFile(filePath) {
     try {
         if (!existsSync(filePath))
             return null;
-        return JSON.parse(readFileSync(filePath, 'utf-8'));
+        return parseJsonWithJsoncFallback(readFileSync(filePath, 'utf-8'));
     }
     catch (error) {
         if (error.code === 'EACCES' || error.code === 'EPERM') {

package/dist/log_config_files/runtime/compliance_check.js

@@ -43,6 +43,8 @@ export function normalizeAgentToken(raw) {
         return 'copilot';
     if (s === 'opencode')
         return 'opencode';
+    if (s === 'codex')
+        return 'codex';
     return '';
 }
 function currentAgentFromEnv() {
@@ -58,6 +60,8 @@ function currentAgentFromEnv() {
         return 'copilot';
     if (hookType === 'opencode')
         return 'opencode';
+    if (hookType === 'codex')
+        return 'codex';
     return 'claude';
 }
 function targetsCurrentAgent(entry, agent) {
@@ -519,6 +523,19 @@ export function reportPostRestartVerificationOutcomes(violations) {
     });
     return { outcomes, reportPromises };
 }
+/**
+ * Run immediately after a deferred state.vscdb write lands on disk (post-restart, before the
+ * user's next prompt) so `pending_post_restart_verify` remediations are confirmed and reported
+ * to the server right away — the UI does not need to wait for another gate invocation.
+ */
+export async function runPostApplyVerification(agent = 'cursor') {
+    const status = runLocalRemediationComplianceCheck(agent);
+    const { outcomes, reportPromises } = reportPostRestartVerificationOutcomes(status.violations);
+    if (outcomes.length > 0) {
+        await Promise.allSettled(reportPromises);
+    }
+    return outcomes;
+}
 /**
  * Immediate autofix succeeded (inline recheck OK or Claude stale-recheck tolerance).
  * Clear pending verification locally and report verified so the next prompt does not POST