evolcore 0.0.33 → 0.0.35-test.0

package/dist/agents/codex/diagnostics.js

@@ -3,8 +3,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { parse as parseToml } from 'smol-toml';
-const managedHookInstaller = await import(new URL('../../../bin/install-codex-managed-hooks.mjs', import.meta.url).href);
+import { TARGET_PACKAGE_ROOT_ENV } from '../../product.js';
 export function checkCodexProjectPath(value, options = {}) {
     const configured = typeof value === 'string' ? value.trim() : '';
     if (!configured) {
@@ -65,12 +67,6 @@ function decodeProbeOutput(buffer) {
         return new TextDecoder('gb18030').decode(buffer);
     }
 }
-function windowsCommandArg(value) {
-    return '"' + value.replaceAll('"', '\\"') + '"';
-}
-function expectedWindowsHookCommand(nodePath, hookPath) {
-    return windowsCommandArg(nodePath) + ' ' + windowsCommandArg(hookPath) + ' %EVOLCORE_INSTANCE_SOCKET%';
-}
 /**
  * Run synthetic Windows shell probes for the managed Codex hook.
  *
@@ -104,13 +100,20 @@ export function runCodexHookLaunchDiagnostic(options = {}) {
         throw new Error('No Windows managed hook directory configured.');
     const managedDir = path.resolve(options.managedDir || configuredDir);
     const hookPath = path.join(managedDir, 'pre-tool-use.mjs');
-    const expected = expectedWindowsHookCommand(nodePath, hookPath);
+    let expected;
     const handlers = Array.isArray(config.hooks?.PreToolUse)
         ? config.hooks.PreToolUse.flatMap((group) => group?.hooks || [])
         : [];
-    const handler = handlers.find((item) => (item?.type === 'command'
-        && (item.command_windows ?? item.commandWindows) === expected));
-    if (!handler || /[\r\n%;&|<>]/.test(nodePath + hookPath)) {
+    const handler = handlers.find((item) => {
+        if (item?.type !== 'command' || item.async === true)
+            return false;
+        const command = parseManagedCommand(item.command_windows ?? item.commandWindows, hookPath);
+        if (!command || !sameRuntimePath(command.nodePath, nodePath, options.platform ?? process.platform))
+            return false;
+        expected = item.command_windows ?? item.commandWindows;
+        return true;
+    });
+    if (!handler || !expected || /[\r\n%;&|<>]/.test(nodePath + hookPath)) {
         throw new Error('Managed command differs from the expected EvolCore command for this Node path; no hooks executed.');
     }
     fs.mkdirSync(path.dirname(output), { recursive: true, mode: 0o700 });
@@ -202,9 +205,34 @@ function samePackageRoot(embedded, expected) {
     };
     return normalize(embedded) === normalize(expected) || resolved(embedded) === resolved(expected);
 }
+/**
+ * Windows accepts an executable path without its `.exe` suffix. Older
+ * installations may therefore bind `...\\node` while the current Node
+ * process reports `...\\node.exe`; these are the same runtime and must not
+ * trigger an elevated repair on every startup.
+ */
+function sameRuntimePath(embedded, expected, platform) {
+    if (samePackageRoot(embedded, expected))
+        return true;
+    if (platform !== 'win32' || !embedded)
+        return false;
+    const appendExe = (value) => path.extname(value) ? value : `${value}.exe`;
+    return samePackageRoot(appendExe(embedded), expected)
+        || samePackageRoot(embedded, appendExe(expected));
+}
 function normalizedPath(value) {
     return path.normalize(String(value || '')).replace(/[\\/]+$/, '').toLowerCase();
 }
+function parseManagedCommand(value, hookPath) {
+    if (typeof value !== 'string')
+        return null;
+    const match = /^"([^"\r\n]+)"\s+"([^"\r\n]+)"\s+%EVOLCORE_INSTANCE_SOCKET%$/i.exec(value.trim());
+    if (!match || !path.isAbsolute(match[1]) || /[%!]/.test(match[1] + match[2]))
+        return null;
+    if (normalizedPath(match[2]) !== normalizedPath(hookPath))
+        return null;
+    return { nodePath: match[1] };
+}
 function runtimeFileMayExist(file) {
     try {
         return fs.statSync(file).isFile();
@@ -213,9 +241,6 @@ function runtimeFileMayExist(file) {
         return !['ENOENT', 'ENOTDIR'].includes(error?.code || '');
     }
 }
-function managedBinding(source, launcher, hookPath) {
-    return managedHookInstaller.managedBinding(source, launcher, hookPath);
-}
 /** Read-only inspection of the machine-wide Windows Codex managed hook. */
 export function inspectCodexManagedHook(options = {}) {
     const paths = codexManagedHookPaths(options);
@@ -224,6 +249,21 @@ export function inspectCodexManagedHook(options = {}) {
     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');
+    let managedHookInstaller;
+    try {
+        const installer = fileURLToPath(new URL('../../../bin/install-codex-managed-hooks.mjs', import.meta.url));
+        managedHookInstaller = createRequire(import.meta.url)(installer);
+        if (typeof managedHookInstaller.managedBinding !== 'function') {
+            throw new Error('managedBinding export is unavailable');
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'unsafe', requirements, managedDir, hookPath,
+            reason: `managed-hook installer could not be loaded: ${detail}`,
+        };
+    }
     const configDirState = realDirectoryState(path.dirname(requirements));
     const managedDirState = realDirectoryState(managedDir);
     if ([configDirState, managedDirState].includes('unsafe')) {
@@ -286,9 +326,9 @@ export function inspectCodexManagedHook(options = {}) {
     catch (error) {
         return { status: 'unavailable', requirements, managedDir, hookPath, reason: error instanceof Error ? error.message : String(error) };
     }
-    const expectedPackageRoot = path.resolve(options.packageRoot || process.cwd());
+    const expectedPackageRoot = path.resolve(process.env[TARGET_PACKAGE_ROOT_ENV] || options.packageRoot || process.cwd());
     try {
-        const binding = managedBinding(source, launcher, hookPath);
+        const binding = managedHookInstaller.managedBinding(source, launcher, hookPath);
         if (!binding || config.allow_managed_hooks_only !== true || config.features?.hooks !== true
             || normalizedPath(config.hooks?.windows_managed_dir) !== normalizedPath(managedDir)
             || (config.hooks?.managed_dir !== undefined
@@ -297,7 +337,7 @@ export function inspectCodexManagedHook(options = {}) {
         }
         const { embeddedPackageRoot, managedNodePath } = binding;
         const packageMatches = samePackageRoot(embeddedPackageRoot, expectedPackageRoot);
-        const nodeMatches = samePackageRoot(managedNodePath, options.nodePath || process.execPath);
+        const nodeMatches = sameRuntimePath(managedNodePath, options.nodePath || process.execPath, options.platform ?? process.platform);
         const repairFingerprint = createHash('sha256').update(source).update('\0').update(launcher).digest('hex');
         if (packageMatches && nodeMatches)
             return { status: 'installed', requirements, managedDir, hookPath };
@@ -356,9 +396,10 @@ export async function ensureCodexManagedHook(options) {
     });
     if (!paths)
         return { status: 'skipped', reason: 'Windows managed hooks are not applicable on this platform' };
+    const packageRoot = process.env[TARGET_PACKAGE_ROOT_ENV] || options.packageRoot;
     const inspectOptions = {
         platform: platformName,
-        packageRoot: options.packageRoot,
+        packageRoot,
         requirements: options.requirements || paths.requirements,
         managedDir: options.managedDir || paths.managedDir,
         programData: options.programData,
@@ -388,7 +429,9 @@ export async function ensureCodexManagedHook(options) {
         || rechecked.repairAmbiguous !== state.repairAmbiguous) {
         return { ...rechecked, repaired: false, error: 'managed-hook state changed during the startup check; retry to confirm the current binding' };
     }
-    const installer = path.join(path.resolve(options.packageRoot), 'bin', 'install-codex-managed-hooks.mjs');
+    const installer = process.env[TARGET_PACKAGE_ROOT_ENV]
+        ? fileURLToPath(new URL('../../../bin/install-codex-managed-hooks.mjs', import.meta.url))
+        : path.join(path.resolve(packageRoot), 'bin', 'install-codex-managed-hooks.mjs');
     if (!fs.existsSync(installer)) {
         return { ...state, repaired: false, error: `managed-hook installer is missing: ${installer}` };
     }
@@ -412,15 +455,29 @@ export async function ensureCodexManagedHook(options) {
         if (result.error)
             return { ok: false, detail: result.error.message };
         if (result.status !== 0) {
-            const detail = (result.stderr || '').replace(/#<\s*CLIXML[\s\S]*?<\/Objs>\s*/gi, '').trim();
-            return { ok: false, detail: detail || `installer exited with code ${result.status}` };
+            const stderrDetail = (result.stderr || '').replace(/#<\s*CLIXML[\s\S]*?<\/Objs>\s*/gi, '').trim();
+            // The elevated child process runs in a separate window and its stderr is
+            // not captured through the Start-Process pipe. Read the structured failure
+            // record the installer writes to ProgramData before exiting.
+            let fileDetail;
+            try {
+                const failurePath = path.join(path.dirname(path.resolve(inspectOptions.requirements || paths.requirements)), '.evolcore-install-failure.json');
+                const raw = fs.readFileSync(failurePath, 'utf8');
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.message === 'string' && parsed.message)
+                    fileDetail = parsed.message;
+                fs.rmSync(failurePath, { force: true });
+            }
+            catch { /* best-effort */ }
+            const detail = fileDetail || stderrDetail || `installer exited with code ${result.status}`;
+            return { ok: false, detail };
         }
         return { ok: true };
     });
     options.onInstallRequired?.(state);
     let elevated;
     try {
-        elevated = runElevated(installer, path.resolve(options.packageRoot));
+        elevated = runElevated(installer, path.resolve(packageRoot));
     }
     catch (error) {
         elevated = { ok: false, detail: error instanceof Error ? error.message : String(error) };