evolcore 0.0.21 → 0.0.23

package/dist/agents/codex/diagnostics.js

@@ -0,0 +1,154 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parse as parseToml } from 'smol-toml';
+export function checkCodexProjectPath(value, options = {}) {
+    const configured = typeof value === 'string' ? value.trim() : '';
+    if (!configured) {
+        return { status: 'invalid', path: configured, warnings: [], reason: 'projects.defaultPath is not configured' };
+    }
+    const projectPath = path.resolve(configured);
+    const warnings = [];
+    if ((options.platform ?? process.platform) === 'win32') {
+        if (projectPath.length >= 240) {
+            warnings.push(`Windows path is long (${projectPath.length} characters); Codex or a child tool may reject it.`);
+        }
+        if (projectPath.startsWith('\\\\')) {
+            warnings.push('Windows UNC/network project path may be unavailable to Codex sandboxed processes.');
+        }
+        const systemRoot = process.env.SystemRoot ? path.resolve(process.env.SystemRoot).toLowerCase() : '';
+        if (systemRoot && projectPath.toLowerCase().startsWith(`${systemRoot}${path.sep}`)) {
+            warnings.push('Project path is under the Windows system directory; use a dedicated workspace when possible.');
+        }
+    }
+    const root = path.parse(projectPath).root;
+    if (projectPath === root)
+        warnings.push('Project path is a filesystem root; use a dedicated project directory when possible.');
+    try {
+        const stat = fs.statSync(projectPath);
+        if (!stat.isDirectory())
+            return { status: 'not-directory', path: projectPath, warnings, reason: 'path exists but is not a directory' };
+        try {
+            fs.accessSync(projectPath, fs.constants.R_OK | fs.constants.W_OK);
+        }
+        catch (error) {
+            return { status: 'inaccessible', path: projectPath, warnings, reason: error instanceof Error ? error.message : String(error) };
+        }
+        return { status: 'ok', path: projectPath, warnings };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { status: 'missing', path: projectPath, warnings, reason: 'directory does not exist' };
+        }
+        return { status: 'inaccessible', path: projectPath, warnings, reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function codexManagedHookPaths(options = {}) {
+    if ((options.platform ?? process.platform) !== 'win32')
+        return null;
+    const programData = options.programData || process.env.ProgramData || path.join(options.homeDir || os.homedir(), 'ProgramData');
+    const requirements = path.resolve(programData, 'OpenAI', 'Codex', 'requirements.toml');
+    const managedDir = path.join(path.dirname(requirements), 'EvolCore', 'hooks');
+    return { requirements, managedDir, hookPath: path.join(managedDir, 'pre-tool-use.mjs') };
+}
+function regularFileState(file) {
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return 'unsafe';
+        return 'ok';
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return 'missing';
+        return 'unavailable';
+    }
+}
+function realDirectoryState(directory) {
+    try {
+        const stat = fs.lstatSync(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return 'unsafe';
+        return 'ok';
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return 'missing';
+        return 'unavailable';
+    }
+}
+/** Read-only inspection of the machine-wide Windows Codex managed hook. */
+export function inspectCodexManagedHook(options = {}) {
+    const paths = codexManagedHookPaths(options);
+    if (!paths)
+        return { status: 'skipped', reason: 'Windows managed hooks are not applicable on this platform' };
+    const requirements = path.resolve(options.requirements || paths.requirements);
+    const managedDir = path.resolve(options.managedDir || paths.managedDir);
+    const hookPath = path.join(managedDir, 'pre-tool-use.mjs');
+    const configDirState = realDirectoryState(path.dirname(requirements));
+    const managedDirState = realDirectoryState(managedDir);
+    if ([configDirState, managedDirState].includes('unsafe')) {
+        return { status: 'unsafe', requirements, managedDir, hookPath, reason: 'requirements or managed-hook directory is not a real directory' };
+    }
+    if ([configDirState, managedDirState].includes('unavailable')) {
+        return { status: 'unavailable', requirements, managedDir, hookPath, reason: 'unable to inspect requirements or managed-hook directory' };
+    }
+    const requirementState = regularFileState(requirements);
+    const hookState = regularFileState(hookPath);
+    if ([requirementState, hookState].includes('unsafe')) {
+        return { status: 'unsafe', requirements, managedDir, hookPath, reason: 'requirements.toml or launcher is not a regular file' };
+    }
+    if ([requirementState, hookState].includes('unavailable')) {
+        return { status: 'unavailable', requirements, managedDir, hookPath, reason: 'unable to read requirements.toml or launcher' };
+    }
+    if ([requirementState, hookState].includes('missing')) {
+        return { status: 'missing', requirements, managedDir, hookPath, reason: 'requirements.toml or launcher is missing' };
+    }
+    let config;
+    let launcher;
+    let source;
+    try {
+        source = fs.readFileSync(requirements, 'utf8');
+    }
+    catch (error) {
+        return { status: 'unavailable', requirements, managedDir, hookPath, reason: error instanceof Error ? error.message : String(error) };
+    }
+    try {
+        config = parseToml(source);
+    }
+    catch (error) {
+        return { status: 'unsafe', requirements, managedDir, hookPath, reason: `requirements.toml is invalid: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    try {
+        launcher = fs.readFileSync(hookPath, 'utf8');
+    }
+    catch (error) {
+        return { status: 'unavailable', requirements, managedDir, hookPath, reason: error instanceof Error ? error.message : String(error) };
+    }
+    const normalized = (value) => path.normalize(String(value || '')).toLowerCase();
+    const expectedPackageRoot = path.resolve(options.packageRoot || process.cwd());
+    const launcherValid = launcher.includes('EVOLCORE_MANAGED_HOOK_LAUNCHER')
+        && launcher.toLowerCase().includes(JSON.stringify(expectedPackageRoot).toLowerCase());
+    const configuredDir = config.hooks?.windows_managed_dir ?? config.hooks?.managed_dir;
+    const groups = config.hooks?.PreToolUse;
+    const canonicalCommand = (value) => {
+        if (typeof value !== 'string' || !value || /[\r\n;&|<>]/.test(value))
+            return false;
+        const withoutSocket = value.replace(/\s+%EVOLCORE_INSTANCE_SOCKET%\s*$/i, '').trim();
+        return withoutSocket.replace(/["']+$/, '').toLowerCase().endsWith(normalized(hookPath));
+    };
+    const hookLoaded = Array.isArray(groups) && groups.some((group) => group?.matcher === '*'
+        && Array.isArray(group.hooks) && group.hooks.some((handler) => {
+        const command = typeof handler?.command === 'string' ? handler.command : '';
+        const windowsCommand = typeof handler?.command_windows === 'string' ? handler.command_windows : '';
+        return handler?.type === 'command' && handler.async !== true
+            && canonicalCommand(command) && canonicalCommand(windowsCommand);
+    }));
+    const valid = config.allow_managed_hooks_only === true
+        && config.features?.hooks === true
+        && normalized(configuredDir) === normalized(managedDir)
+        && launcherValid && hookLoaded;
+    return valid
+        ? { status: 'installed', requirements, managedDir, hookPath }
+        : { status: 'unsafe', requirements, managedDir, hookPath, reason: 'managed-hook policy is missing, altered, or points outside the canonical target' };
+}