@crewx/cli 0.9.0-rc.111 → 0.9.0-rc.112

package/dist/commands/detached.js

@@ -293,6 +293,9 @@ function runnerCommand(command) {
 function buildRunnerEnvironment(taskId) {
     const env = { ...process.env };
     delete env[INTERNAL_TOKEN_ENV];
+    if (process.versions.electron) {
+        env.ELECTRON_RUN_AS_NODE = '1';
+    }
     env.CREWX_DETACHED_RUNNER = '1';
     env.CREWX_ASSIGNED_TASK_ID = taskId;
     return env;
@@ -328,6 +331,9 @@ function readAssignedTaskActor(taskRepo, taskId) {
 }
 function buildMiddleEnvironment(token) {
     const env = { ...process.env };
+    if (process.versions.electron) {
+        env.ELECTRON_RUN_AS_NODE = '1';
+    }
     env[INTERNAL_TOKEN_ENV] = token;
     return env;
 }

package/dist/commands/doctor.d.ts

@@ -6,6 +6,7 @@
  *   crewx doctor                  Run full diagnosis
  *   crewx doctor --config <path>  Use specific config file
  */
+import type { CrewxExecutableResolution, CrewxExecutableStage } from '@crewx/sdk';
 interface DiagnosticResult {
     name: string;
     status: 'success' | 'warning' | 'error';
@@ -44,6 +45,25 @@ export interface CrewxShimReport {
         fingerprint: string;
     }>;
 }
+export interface CrewxExecutableReport {
+    platform: NodeJS.Platform;
+    pathCandidates: string[];
+    stage?: CrewxExecutableStage;
+    argv?: string[];
+    electron: boolean;
+    requiredEnvKeys: string[];
+    binResolution: 'global_first' | 'local_first';
+    adoptedPath?: string;
+    resolutionError?: string;
+}
+export interface CrewxExecutableInspectionOptions {
+    platform?: NodeJS.Platform;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    binResolution?: 'global_first' | 'local_first';
+    pathCandidates?: readonly string[];
+    resolution?: CrewxExecutableResolution;
+}
 /** CLI diagnostics keyed by the bare provider name used in PROVIDER_ORDER. */
 export declare const CLI_PROVIDER_INFO: Record<string, CliProviderInfo>;
 /** Format a byte count for diagnostic output. */
@@ -52,6 +72,10 @@ export declare function formatBytes(bytes: number): string;
 export declare function inspectNpxCache(cacheRoot?: string): NpxCacheReport;
 /** Inspect installed CrewX hooks without rewriting provider settings. */
 export declare function inspectHookCommands(projectRoot: string): HookCommandReport;
+/** Inspect the SDK-selected CrewX executable without printing environment values. */
+export declare function inspectCrewxExecutable(options?: CrewxExecutableInspectionOptions & {
+    configPath?: string;
+}): CrewxExecutableReport;
 /** Inspect orphaned CrewX PATH shim directories without modifying them. */
 export declare function inspectCrewxShims(crewxHome?: string, resolvedFingerprint?: string | undefined): CrewxShimReport;
 /**

package/dist/commands/doctor.js

@@ -12,10 +12,10 @@ exports.CLI_PROVIDER_INFO = void 0;
 exports.formatBytes = formatBytes;
 exports.inspectNpxCache = inspectNpxCache;
 exports.inspectHookCommands = inspectHookCommands;
+exports.inspectCrewxExecutable = inspectCrewxExecutable;
 exports.inspectCrewxShims = inspectCrewxShims;
 exports.checkCliProviders = checkCliProviders;
 exports.handleDoctor = handleDoctor;
-const node_crypto_1 = require("node:crypto");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -255,17 +255,98 @@ function inspectHookCommands(projectRoot) {
     }
     return { inspectedFiles, issues };
 }
-function currentShimFingerprint() {
-    const resolution = (0, sdk_1.resolveCrewxExecutable)();
-    if (!resolution.ok)
-        return undefined;
-    return (0, node_crypto_1.createHash)('sha256')
-        .update(JSON.stringify(resolution.argv))
-        .digest('hex')
-        .slice(0, 16);
+function configuredBinResolution(configPath, fallback = 'global_first') {
+    try {
+        const config = (0, sdk_1.loadYamlFile)(configPath);
+        const value = config.settings?.bin_resolution;
+        return value === 'local_first' || value === 'global_first' ? value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function readWindowsCrewxPathCandidates(cwd, env, platform) {
+    if (platform !== 'win32')
+        return [];
+    try {
+        (0, sdk_1.primeWindowsConsoleCodePage)();
+        const output = (0, node_child_process_1.execFileSync)('where.exe', ['crewx'], {
+            cwd,
+            env,
+            encoding: null,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return (0, sdk_1.decodeConsoleBuffer)(output, { platform })
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/** Inspect the SDK-selected CrewX executable without printing environment values. */
+function inspectCrewxExecutable(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const cwd = (0, node_path_1.resolve)(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const configPath = options.configPath ?? (0, node_path_1.join)(cwd, 'crewx.yaml');
+    const resolution = options.resolution ?? (0, sdk_1.resolveCrewxExecutable)({ env, cwd, platform });
+    const pathCandidates = options.pathCandidates
+        ? [...options.pathCandidates]
+        : readWindowsCrewxPathCandidates(cwd, env, platform);
+    const requiredEnvKeys = resolution.ok
+        ? Object.keys(resolution.requiredEnv ?? {})
+            .filter((key) => key === 'ELECTRON_RUN_AS_NODE')
+        : [];
+    return {
+        platform,
+        pathCandidates,
+        ...(resolution.ok
+            ? {
+                stage: resolution.stage,
+                argv: [...resolution.argv],
+                adoptedPath: resolution.argv[0],
+            }
+            : { resolutionError: resolution.reason }),
+        electron: requiredEnvKeys.includes('ELECTRON_RUN_AS_NODE'),
+        requiredEnvKeys,
+        binResolution: options.binResolution ?? configuredBinResolution(configPath),
+    };
+}
+function checkCrewxExecutable(report) {
+    const details = [
+        `platform: ${report.platform}`,
+        `stage: ${report.stage ?? '(unresolved)'}`,
+        `argv: ${report.argv ? (0, sdk_1.formatCrewxExecutableArgv)(report.argv) : '(unresolved)'}`,
+        `adopted path: ${report.adoptedPath ?? '(none)'}`,
+        `Electron runtime: ${report.electron ? 'yes' : 'no'}`,
+        `required environment keys: ${report.requiredEnvKeys.length > 0 ? report.requiredEnvKeys.join(', ') : '(none)'}`,
+        `bin_resolution setting: ${report.binResolution}`,
+        ...(report.platform === 'win32'
+            ? [`where.exe crewx candidates: ${report.pathCandidates.length > 0 ? report.pathCandidates.join(', ') : '(none)'}`]
+            : []),
+    ];
+    if (report.resolutionError) {
+        return {
+            name: 'CrewX Executable',
+            status: 'warning',
+            message: 'Could not resolve the CrewX executable',
+            details: `${details.join('\n')}\nResolution failed; no environment values were printed.`,
+        };
+    }
+    return {
+        name: 'CrewX Executable',
+        status: 'success',
+        message: 'SDK child executable contract is available',
+        details: details.join('\n'),
+    };
 }
 /** Inspect orphaned CrewX PATH shim directories without modifying them. */
-function inspectCrewxShims(crewxHome = (0, sdk_1.getCrewxHome)(), resolvedFingerprint = currentShimFingerprint()) {
+function inspectCrewxShims(crewxHome = (0, sdk_1.getCrewxHome)(), resolvedFingerprint = (() => {
+    const resolution = (0, sdk_1.resolveCrewxExecutable)();
+    return resolution.ok ? (0, sdk_1.crewxCliShimFingerprint)(resolution) : undefined;
+})()) {
     const shimRoot = (0, node_path_1.join)((0, node_path_1.resolve)(crewxHome), 'bin-shim');
     const staleDirectories = [];
     if (resolvedFingerprint) {
@@ -526,6 +607,7 @@ async function handleDoctor(args) {
     let shims = inspectCrewxShims();
     const projectRoot = (0, node_path_1.dirname)((0, node_path_1.resolve)(configPath));
     const hooks = inspectHookCommands(projectRoot);
+    const executable = inspectCrewxExecutable({ configPath, cwd: process.cwd() });
     if (cleanNpxCache) {
         cleanDoctorArtifacts(npxCache, shims);
         npxCache = inspectNpxCache();
@@ -535,6 +617,7 @@ async function handleDoctor(args) {
         checkConfig(configPath),
         checkLogsDir(),
         checkEnvVars(),
+        checkCrewxExecutable(executable),
         ...checkCliProviders(),
         checkNpxCache(npxCache),
         checkHookCommands(hooks),

package/dist/commands/hook/install.js

@@ -32,9 +32,26 @@ function resolveCrewxBinary() {
     if (!resolution.ok) {
         throw new Error((0, sdk_1.formatCrewxExecutableFailure)(resolution));
     }
-    const stableEntrypoint = (0, sdk_1.materializeCrewxStableEntrypoint)(resolution);
-    const useStable = stableEntrypoint && resolution.argv.some(sdk_1.isRotatingInstallPath);
-    return (0, sdk_1.formatCrewxExecutableArgv)(useStable ? [stableEntrypoint] : resolution.argv);
+    let stableEntrypoint;
+    try {
+        stableEntrypoint = (0, sdk_1.materializeCrewxStableEntrypoint)(resolution, { allowEnvStage: true });
+    }
+    catch (error) {
+        if (resolution.requiredEnv && Object.keys(resolution.requiredEnv).length > 0) {
+            throw new Error(`CrewX hook entrypoint could not preserve required environment: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        throw error;
+    }
+    if (stableEntrypoint) {
+        return (0, sdk_1.formatCrewxExecutableArgv)([stableEntrypoint]);
+    }
+    // A required runtime environment cannot be represented by a raw argv string,
+    // and the fingerprint shim directory is doctor-GC managed. Refuse to write
+    // either representation when the stable hook path was not eligible.
+    if (resolution.requiredEnv && Object.keys(resolution.requiredEnv).length > 0) {
+        throw new Error('CrewX hook entrypoint could not preserve required environment: stable entrypoint is not eligible for this executable');
+    }
+    return (0, sdk_1.formatCrewxExecutableArgv)(resolution.argv);
 }
 function readSettingsTyped(settingsPath) {
     return (0, paths_1.readSettings)(settingsPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/cli",
-  "version": "0.9.0-rc.111",
+  "version": "0.9.0-rc.112",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"
@@ -25,19 +25,19 @@
     "better-sqlite3": "*",
     "dotenv": "17.2.3",
     "isomorphic-git": "1.37.1",
-    "@crewx/knowledge-core": "0.1.17-rc.121",
-    "@crewx/sdk": "0.9.0-rc.111",
-    "@crewx/memory": "0.1.23-rc.128",
-    "@crewx/doc": "0.1.9-rc.104",
-    "@crewx/cron": "0.1.10-rc.146",
-    "@crewx/search": "0.1.10-rc.107",
-    "@crewx/skill": "0.1.20-rc.5",
-    "@crewx/workflow": "0.3.22-rc.157",
-    "@crewx/chromex": "0.1.0-rc.144",
-    "@crewx/wbs": "0.1.10-rc.137",
-    "@crewx/notify": "0.1.0-rc.82",
-    "@crewx/shared": "0.0.6-rc.26",
-    "@crewx/wi": "0.1.10-rc.131"
+    "@crewx/knowledge-core": "0.1.17-rc.122",
+    "@crewx/sdk": "0.9.0-rc.112",
+    "@crewx/memory": "0.1.23-rc.129",
+    "@crewx/cron": "0.1.10-rc.147",
+    "@crewx/search": "0.1.10-rc.108",
+    "@crewx/doc": "0.1.9-rc.105",
+    "@crewx/wbs": "0.1.10-rc.138",
+    "@crewx/workflow": "0.3.22-rc.158",
+    "@crewx/skill": "0.1.20-rc.6",
+    "@crewx/notify": "0.1.0-rc.83",
+    "@crewx/chromex": "0.1.0-rc.145",
+    "@crewx/shared": "0.0.6-rc.27",
+    "@crewx/wi": "0.1.10-rc.132"
   },
   "devDependencies": {
     "@types/better-sqlite3": "*",