log-llm-config-staging 1.4.1 → 1.4.3

package/dist/log_config_files/collection/skills_cli_collector.js

@@ -0,0 +1,134 @@
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const SKILLS_CLI_FILE_TYPE = 'skills_cli_installed';
+export const SKILLS_CLI_INSTALLED_PATH = join(homedir(), '.agents', '.skills-cli-installed.json');
+/** Override fallback runner, e.g. `skills@1.5.10`. Default `skills` uses the machine npx cache. */
+export const SKILLS_CLI_NPX_PACKAGE_ENV = 'SKILLS_CLI_NPX_PACKAGE';
+const LIST_TIMEOUT_MS = 120_000;
+function listExecEnv() {
+    return {
+        ...process.env,
+        DISABLE_TELEMETRY: process.env.DISABLE_TELEMETRY ?? '1',
+    };
+}
+function npxPackageSpecForFallback() {
+    const fromEnv = (process.env[SKILLS_CLI_NPX_PACKAGE_ENV] || '').trim();
+    return fromEnv || 'skills';
+}
+function resolveSkillsListRunner() {
+    try {
+        const require = createRequire(fileURLToPath(import.meta.url));
+        const bin = require.resolve('skills/bin/cli.mjs');
+        const pkg = require('skills/package.json');
+        const version = (pkg.version || '').trim() || 'unknown';
+        return { mode: 'bundled', bin, version };
+    }
+    catch {
+        return { mode: 'npx', packageSpec: npxPackageSpecForFallback() };
+    }
+}
+function execSkillsList(args, cwd, runner) {
+    if (runner.mode === 'bundled') {
+        return execFileSync(process.execPath, [runner.bin, 'list', ...args, '--json'], {
+            encoding: 'utf8',
+            cwd,
+            timeout: LIST_TIMEOUT_MS,
+            env: listExecEnv(),
+        });
+    }
+    return execFileSync('npx', ['--yes', runner.packageSpec, 'list', ...args, '--json'], {
+        encoding: 'utf8',
+        cwd,
+        timeout: LIST_TIMEOUT_MS,
+        env: listExecEnv(),
+    });
+}
+function runnerVersionLabel(runner) {
+    if (runner.mode === 'bundled')
+        return runner.version;
+    return `npx:${runner.packageSpec}`;
+}
+export function runSkillsListJson(args, cwd) {
+    const runner = resolveSkillsListRunner();
+    const out = execSkillsList(args, cwd, runner);
+    const trimmed = out.trim();
+    if (!trimmed)
+        return [];
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed;
+}
+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}`;
+}
+export function collectSkillsCliInstalled(projectRoot, log) {
+    const logLine = (message) => {
+        log?.(message);
+    };
+    try {
+        const runner = resolveSkillsListRunner();
+        if (runner.mode === 'bundled') {
+            logLine(`skills_cli: bundled skills@${runner.version} — list -g --json && list --json (projectRoot=${projectRoot})`);
+        }
+        else {
+            logLine(`skills_cli: npx fallback (${runner.packageSpec}) — no bundled skills dep; uses machine npx cache (projectRoot=${projectRoot})`);
+        }
+        const globalRows = runSkillsListJson(['-g'], projectRoot);
+        const projectRows = runSkillsListJson([], projectRoot);
+        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: runnerVersionLabel(runner),
+            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,
+        };
+    }
+    catch (err) {
+        logLine(`skills_cli: list --json failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

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 with 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('**');
@@ -67,6 +81,29 @@ 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, '/');
     if (!norm.includes('*'))
@@ -111,12 +148,16 @@ function expandGlobPathPattern(pathPattern, fileType, home, projectRoot, content
             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 (!entry.isDirectory())
+                    if (!entryMatches(entry))
                         continue;
                     recurse(join(currentPath, entry.name), segIdx + 1);
                 }
@@ -131,7 +172,7 @@ function expandGlobPathPattern(pathPattern, fileType, home, projectRoot, content
                 return;
             try {
                 for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
-                    if (!entry.isDirectory())
+                    if (!entryMatches(entry))
                         continue;
                     if (prefix && !entry.name.startsWith(prefix))
                         continue;

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) {

package/dist/log_config_files/runtime/hook_type_for_request.js

@@ -6,7 +6,7 @@ function normalizeToken(raw) {
         return 'claude';
     if (s === 'github_copilot')
         return 'copilot';
-    if (s === 'cursor' || s === 'claude' || s === 'copilot' || s === 'opencode')
+    if (s === 'cursor' || s === 'claude' || s === 'copilot' || s === 'opencode' || s === 'codex')
         return s;
     // Legacy hooks set OPTIMUS_AGENT=Cursor (display casing)
     if (raw.trim() === 'Cursor')
@@ -24,5 +24,7 @@ export function resolveHookTypeFromEnv(env = process.env) {
         return 'copilot';
     if (token === 'opencode')
         return 'opencode';
+    if (token === 'codex')
+        return 'codex';
     return 'claude';
 }

package/dist/log_config_files/runtime/main_runner.js

@@ -14,6 +14,7 @@ import { readJSONFile, readMarkdownFile } from '../readers/file_readers.js';
 import { isVscdbVirtualPath, tryReadVscdbVirtualFile, summarizeComposerPayloadForDiagnostics, } from '../readers/vscdb_config_builder.js';
 import { persistVscdbComposerContractFromPatternsResponse } from '../readers/vscdb_reader.js';
 import { collectConfigFilesFromPatterns, collectMcpToolFiles, collectConfigFilesFromInstalledPlugins, collectPluginCacheMcpFiles, collectMcpFromClaudeJsonProjects, collectClaudeDesktopExtensionManifests, collectClaudeDesktopExtensionSettingsFiles, enrichClaudeDesktopExtensionsInstallationsUpload, determineFileTypeFromPath, } from '../collection/config_collector.js';
+import { collectSkillsCliInstalled } from '../collection/skills_cli_collector.js';
 import { collectWorkspaceVscdbs } from '../collection/mcp_tool_collector.js';
 import { collectCursorProjectWorkspaceMcpConfigs } from '../collection/cursor_project_mcp_collector.js';
 import { normalizePathSkipPrefixes } from '../paths/pattern_resolver.js';
@@ -115,6 +116,14 @@ async function collectAllConfigFiles(endpointBase) {
             }
         }
     }
+    const skillsCliEntry = collectSkillsCliInstalled(PROJECT_ROOT, hookRunLog);
+    if (skillsCliEntry) {
+        const key = `${skillsCliEntry.file_type}\t${skillsCliEntry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(skillsCliEntry);
+        }
+    }
     const worktreeReport = scanActiveWorktrees(PROJECT_ROOT, HOME_DIR);
     const activeRoots = activeWorktreeRootSet(worktreeReport);
     const beforeFilter = configFiles.length;

package/dist/log_config_files/runtime/trusted_restarts.js

@@ -36,6 +36,8 @@ function currentAgentFromEnv() {
         return 'copilot';
     if (override === 'opencode')
         return 'opencode';
+    if (override === 'codex')
+        return 'codex';
     if (override === 'claude' || override === 'claude_desktop')
         return 'claude';
     const hookType = normalizeAgentToken(process.env.OPTIMUS_HOOK_TYPE);
@@ -45,6 +47,8 @@ function currentAgentFromEnv() {
         return 'copilot';
     if (hookType === 'opencode')
         return 'opencode';
+    if (hookType === 'codex')
+        return 'codex';
     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.4.1",
+  "version": "1.4.3",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {
@@ -58,6 +58,7 @@
   "dependencies": {
     "axios": "^1.15.2",
     "canonicalize": "^2.1.0",
-    "optimus-tofu-staging": "^0.1.17"
+    "optimus-tofu-staging": "^0.1.17",
+    "skills": "1.5.10"
   }
 }