@nowcrew/daemon 0.6.88-beta.28 → 0.6.88-beta.29

package/dist/local-executor.js

@@ -1,15 +1,17 @@
 import { deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
+import { buildLocalRuntimeEnvironment } from "./local-runtime-environment.js";
+import { environmentForExecution } from "./agent-environments.js";
+import { prepareEnvironmentExecutionSnapshot } from "./agent-environment-execution.js";
 import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
-import { delimiter, join } from "node:path";
+import { join } from "node:path";
 import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
 import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
 import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
-import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { spawnKimi } from "./runtimes/kimi.js";
 import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
-import { augmentedPath } from "./runtime-path.js";
 import { deliverCloudReports, prepareCloudReportExecution } from "./cloud-report-uploader.js";
 import { reportDeliveryContext } from "./cloud-report-receipt.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
@@ -39,9 +41,7 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
-import { machinePackageManagerEnv } from "./package-manager-env.js";
 import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
-import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
 import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
@@ -252,10 +252,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
     let localMemoryResultPath = null;
+    let environmentSnapshot;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
     let nativeThreadContext = null;
-    const inheritedEnv = { ...process.env };
+    const machineSnapshot = dependencies.machineEnvironment ? await awaitWithCancellation(dependencies.machineEnvironment.acquire(), dependencies.cancellation) : undefined;
+    const inheritedEnv = { ...(machineSnapshot?.env ?? process.env) };
     const reportRoots = {
         root: workspace.dir,
         ...(input.launch.qaReportRoot === undefined ? {} : { qaReportRoot: input.launch.qaReportRoot }),
@@ -479,45 +481,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             nativeThreadContext = new NativeThreadContext(join(executionWorkspace.runDir, `.crew-context-${input.executionId}.json`), contextThreadId, runtime.name, resumeSessionId, prior);
             await nativeThreadContext.initialize();
         }
-        const baseEnv = {
-            ...inheritedEnv,
-            ...sanitizeEnvVars(providerConfig.envVars),
-            ...(input.trainingProjectContext === undefined
-                ? {}
-                : machinePackageManagerEnv(inheritedEnv)),
-            ...input.launch.systemEnv,
-            PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,
-            CREW_SERVER_URL: input.launch.serverUrl,
-            CREW_TOKEN: input.launch.token,
-            CREW_CHANNEL: input.channelId,
-            CREW_HOME: crewHome,
-            // Empty values override any stale inherited hints from an enclosing runtime.
-            CREW_THREAD_ROOT: contextThreadId ?? "",
-            CREW_THREAD_CONTEXT_FILE: nativeThreadContext?.path ?? "",
-            // Keep the daemon-selected storage root authoritative for runtimes.
-            // In profile-backed NowWork sessions the daemon config may differ from
-            // the daemon process environment, so inheriting CREW_AGENTS_ROOT is not
-            // sufficient for QA/project diagnostics.
-            CREW_AGENTS_ROOT: input.launch.agentsRoot,
-            ...(input.launch.reposRoot === undefined ? {} : { NOWWORK_REPOS_ROOT: input.launch.reposRoot }),
-            ...(input.launch.qaReportRoot === undefined ? {} : { QA_REPORT_HUB: input.launch.qaReportRoot }),
-            // Expose only the training root; ability-specific workspace layout stays
-            // owned by the training package rather than the NowWork daemon.
-            QA_RUNTIME_ROOT: join(crewHome, "training"),
-            QA_REPORT_DELIVERY_CONTEXT: JSON.stringify(reportContext),
-            CREW_TASK_DIR: executionWorkspace.runDir,
-            CREW_TASK_LOG: executionWorkspace.workLogPath,
-            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
-            XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
-            XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
-            XDG_CACHE_HOME: join(workspace.homeDir, ".cache"),
-            GH_CONFIG_DIR: join(workspace.homeDir, ".config", "gh"),
-            CLOUDSDK_CONFIG: join(workspace.homeDir, ".config", "gcloud"),
-            ...(runtime.name === "kimi" && runtime.reasoning
-                && KIMI_EFFORT_LEVELS.includes(runtime.reasoning)
-                ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
-                : {}),
-        };
+        const baseEnv = buildLocalRuntimeEnvironment({ input, workspace, executionWorkspace, inheritedEnv, providerConfig,
+            crewHome, contextThreadId, nativeThreadContextPath: nativeThreadContext?.path, reportContext, runtime });
         const providerEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir, materializedDeepSeekHome);
         const childEnv = runtime.name === "deepseek-harness"
             ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
@@ -535,10 +500,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const abilityContext = input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
             ? await dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, async (context) => context)
             : undefined;
+        if (providerConfig.environmentPlan !== undefined && !isolatedMaintenance) {
+            environmentSnapshot = await prepareEnvironmentExecutionSnapshot({ plan: providerConfig.environmentPlan, agentRoot: workspace.dir, runDir: executionWorkspace.runDir, executionId: input.executionId, ambient: inheritedEnv, runtime: runtime.name, providerConfig, runtimeEnvironment: childEnv, authoritativeKeys: Object.keys(input.launch.systemEnv ?? {}),
+                executionBaseEnvironment: childEnv,
+                ...(machineSnapshot === undefined ? {} : { machineEnvironmentVersion: { bootId: machineSnapshot.status.bootId, generation: machineSnapshot.status.generation } }),
+                selectedEnvironment: environmentForExecution(providerConfig.environmentPlan, workspace.dir, input.projectContext?.primary?.root ?? executionWorkspace.runDir, input.projectContext?.primary?.projectId),
+                projectRoots: [...(input.projectContext?.primary ? [input.projectContext.primary] : []), ...(input.projectContext?.secondary ?? [])] });
+        }
         const prepareRuntimeLaunch = async (runtimeRoot) => {
-            const effectiveSystemPrompt = abilityContext === undefined
-                ? systemPrompt
-                : `${systemPrompt}\n\n${abilityContext.prompt}`;
+            const effectiveSystemPrompt = [systemPrompt, abilityContext?.prompt, environmentSnapshot?.prompt].filter(Boolean).join("\n\n");
             if (Buffer.byteLength(effectiveSystemPrompt, "utf8") + Buffer.byteLength(memoryPrompt.wakePromptSuffix, "utf8")
                 > (input.maxSystemPromptBytes ?? Number.MAX_SAFE_INTEGER)) {
                 throw new Error("ability_runtime_context_size_exceeded");
@@ -1123,6 +1093,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 active_prune_count: activePruneCount,
             });
         }
+        if (environmentSnapshot)
+            await rm(environmentSnapshot.directory, { recursive: true, force: true }).catch(() => { });
         const attachmentDirectories = new Set([
             ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
             ...(materialized === null ? [] : [materialized.directory]),

package/dist/local-runtime-environment.js

@@ -0,0 +1,50 @@
+import { delimiter, join } from "node:path";
+import { environmentForExecution } from "./agent-environments.js";
+import { augmentedPath } from "./runtime-path.js";
+import { sanitizeEnvVars } from "./runtime-env.js";
+import { machinePackageManagerEnv } from "./package-manager-env.js";
+import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { mergeRuntimeEnvironments } from "./runtime-environment-merge.js";
+/** 机器、目录与受控运行字段分层合并，Windows 不依赖对象中键名的偶然顺序。 */
+export function buildLocalRuntimeEnvironment(context) {
+    const { input, workspace, executionWorkspace, inheritedEnv, providerConfig, crewHome, contextThreadId, nativeThreadContextPath, reportContext, runtime } = context;
+    const agentEnvironment = sanitizeEnvVars(providerConfig.environmentPlan === undefined ? providerConfig.envVars
+        : environmentForExecution(providerConfig.environmentPlan, workspace.dir, input.projectContext?.primary?.root ?? executionWorkspace.runDir, input.projectContext?.primary?.projectId));
+    return mergeRuntimeEnvironments([
+        inheritedEnv, agentEnvironment,
+        input.trainingProjectContext === undefined ? {} : machinePackageManagerEnv(inheritedEnv),
+        input.launch.systemEnv ?? {}, {
+            PATH: `${workspace.crewDir}${delimiter}${augmentedPath(inheritedEnv, {}, process.platform, "append")}`,
+            CREW_SERVER_URL: input.launch.serverUrl,
+            CREW_TOKEN: input.launch.token,
+            CREW_CHANNEL: input.channelId,
+            CREW_HOME: crewHome,
+            // Empty values override any stale inherited hints from an enclosing runtime.
+            CREW_THREAD_ROOT: contextThreadId ?? "",
+            CREW_THREAD_CONTEXT_FILE: nativeThreadContextPath ?? "",
+            // Keep the daemon-selected storage root authoritative for runtimes.
+            // In profile-backed NowWork sessions the daemon config may differ from
+            // the daemon process environment, so inheriting CREW_AGENTS_ROOT is not
+            // sufficient for QA/project diagnostics.
+            CREW_AGENTS_ROOT: input.launch.agentsRoot,
+            ...(input.launch.reposRoot === undefined ? {} : { NOWWORK_REPOS_ROOT: input.launch.reposRoot }),
+            ...(input.launch.qaReportRoot === undefined ? {} : { QA_REPORT_HUB: input.launch.qaReportRoot }),
+            // Expose only the training root; ability-specific workspace layout stays
+            // owned by the training package rather than the NowWork daemon.
+            QA_RUNTIME_ROOT: join(crewHome, "training"),
+            QA_REPORT_DELIVERY_CONTEXT: JSON.stringify(reportContext),
+            CREW_TASK_DIR: executionWorkspace.runDir,
+            CREW_TASK_LOG: executionWorkspace.workLogPath,
+            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
+            XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
+            XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
+            XDG_CACHE_HOME: join(workspace.homeDir, ".cache"),
+            GH_CONFIG_DIR: join(workspace.homeDir, ".config", "gh"),
+            CLOUDSDK_CONFIG: join(workspace.homeDir, ".config", "gcloud"),
+            ...(runtime.name === "kimi" && runtime.reasoning
+                && KIMI_EFFORT_LEVELS.includes(runtime.reasoning)
+                ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
+                : {}),
+        },
+    ]);
+}

package/dist/machine-environment-cache.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+import { copyMachineEnvironment, machineCaptureStartupEnvironment, resolveMachineAccount, restoreMachineEnvironmentOwnership, selectMachineEnvironmentSource, validateMachineEnvironment } from "./machine-environment-policy.js";
+import { captureShellMachineEnvironment, machineEnvironmentSourceFingerprint, machineShellSourceLocations } from "./machine-shell-environment-capture.js";
+function frozenStatus(status) {
+    return Object.freeze({ ...status, sourceLocations: Object.freeze([...new Set(status.sourceLocations)].slice(0, 8)) });
+}
+/** 测试或明确关闭机器环境时使用；永远不会启动 shell，也不读取真实用户 rc。 */
+export function createStaticMachineEnvironmentProvider(startupEnv = {}) {
+    const snapshot = Object.freeze({ env: copyMachineEnvironment(startupEnv), status: frozenStatus({ bootId: randomUUID(), generation: 0, state: "disabled", source: null, sourceLocations: [], capturedAt: null, attemptedAt: null, errorCode: null }) });
+    return { acquire: async () => snapshot, status: () => snapshot.status, stop: async () => { } };
+}
+const sameEnvironment = (left, right) => {
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && left[key] === right[key]);
+};
+export function createMachineEnvironmentProvider(options = {}) {
+    const startup = copyMachineEnvironment(options.startupEnv ?? process.env);
+    const mode = options.mode ?? "auto";
+    const platform = options.platform ?? process.platform;
+    const now = options.now ?? Date.now;
+    let account = Object.freeze({ ...(options.account ?? resolveMachineAccount()) });
+    const selected = selectMachineEnvironmentSource(mode, account, startup, platform);
+    const baseline = startup;
+    const captureStartup = machineCaptureStartupEnvironment(startup, account, platform);
+    let watchedLocations = machineShellSourceLocations({ source: selected.source ?? "windows-registry", account, startupEnv: captureStartup });
+    let sourceFingerprint = null;
+    let snapshot = Object.freeze({ env: baseline, status: frozenStatus({ bootId: randomUUID(), generation: 0, state: mode === "off" ? "disabled" : selected.source === null ? "unsupported" : "loading", source: selected.source, sourceLocations: watchedLocations, capturedAt: null, attemptedAt: null, errorCode: null }) });
+    let lastGood = null;
+    let lastSuccessTime = -Infinity;
+    let lastFailureTime = -Infinity;
+    let stopped = false;
+    let unsafeCleanup = false;
+    let flight;
+    let controller;
+    let captureEpoch = 0;
+    let capturing = false;
+    let forcedFollowup;
+    const sourceOwnedKeys = new Set();
+    const publish = (env, patch) => {
+        snapshot = Object.freeze({ env, status: frozenStatus({ ...snapshot.status, ...patch }) });
+        try {
+            options.onChange?.(snapshot);
+        }
+        catch { /* 观察者失败不能污染已获取的机器环境。 */ }
+        return snapshot;
+    };
+    const captureWindows = options.captureWindows ?? (async (request) => {
+        const module = await import("./machine-windows-environment-capture.js");
+        return module.captureWindowsMachineEnvironment(request);
+    });
+    const refresh = async (force, signal) => {
+        if (!selected.source || stopped || unsafeCleanup)
+            return snapshot;
+        if (!force && now() - lastFailureTime < (options.backoffMs ?? 30_000))
+            return snapshot;
+        const attemptedAt = new Date(now()).toISOString();
+        try {
+            if (!force && lastGood && now() - lastSuccessTime < (options.ttlMs ?? 60_000)) {
+                if (selected.source === "windows-registry" || sourceFingerprint === await machineEnvironmentSourceFingerprint(watchedLocations))
+                    return snapshot;
+            }
+            if (stopped || signal.aborted)
+                return snapshot;
+            publish(snapshot.env, { state: "loading", attemptedAt, errorCode: null });
+            capturing = true;
+            const deadline = Date.now() + (options.captureTimeoutMs ?? (selected.source === "windows-registry" ? 8_000 : 5_000));
+            const capture = selected.source === "windows-registry" ? captureWindows : options.captureShell ?? captureShellMachineEnvironment;
+            for (let attempt = 0; attempt < 2; attempt++) {
+                try {
+                    const before = selected.source === "windows-registry" ? null : await machineEnvironmentSourceFingerprint(watchedLocations);
+                    captureEpoch++;
+                    const captured = await capture({ startupEnv: captureStartup, account, source: selected.source, ...(selected.shellPath ? { shellPath: selected.shellPath } : {}), signal, deadline });
+                    if (signal.aborted)
+                        throw new MachineEnvironmentCaptureError("shell_capture_timeout");
+                    if (before !== null && before !== await machineEnvironmentSourceFingerprint(watchedLocations))
+                        throw new MachineEnvironmentCaptureError("shell_files_changed");
+                    let env = validateMachineEnvironment(captured.env);
+                    let currentOwned;
+                    if (selected.source === "windows-registry") {
+                        currentOwned = new Set((captured.sourceOwnedKeys ?? []).map((key) => key.toUpperCase()));
+                        const merged = new Map();
+                        for (const [key, value] of [...Object.entries(startup), ...Object.entries(env)]) {
+                            if (!sourceOwnedKeys.has(key.toUpperCase()) || currentOwned.has(key.toUpperCase()))
+                                merged.set(key.toUpperCase(), [key, value]);
+                        }
+                        env = Object.fromEntries(merged.values());
+                    }
+                    env = validateMachineEnvironment(restoreMachineEnvironmentOwnership(env, startup, account, platform));
+                    const unchanged = lastGood !== null && sameEnvironment(lastGood.env, env);
+                    const generation = unchanged && lastGood ? lastGood.status.generation : (lastGood?.status.generation ?? 0) + 1;
+                    const locations = [...new Set(captured.sourceLocations)].slice(0, 8);
+                    watchedLocations = locations;
+                    sourceFingerprint = selected.source === "windows-registry" ? null : await machineEnvironmentSourceFingerprint(locations);
+                    for (const key of currentOwned ?? [])
+                        sourceOwnedKeys.add(key);
+                    if (selected.source === "windows-registry" && captured.accountSid)
+                        account = Object.freeze({ ...account, sid: captured.accountSid });
+                    lastSuccessTime = now();
+                    lastFailureTime = -Infinity;
+                    lastGood = publish(unchanged && lastGood ? lastGood.env : env, { state: "ready", generation, sourceLocations: locations, capturedAt: new Date(lastSuccessTime).toISOString(), errorCode: null });
+                    return lastGood;
+                }
+                catch (error) {
+                    if (error instanceof MachineEnvironmentCaptureError && error.code === "shell_files_changed" && attempt === 0 && Date.now() < deadline && !signal.aborted)
+                        continue;
+                    throw error;
+                }
+            }
+            throw new MachineEnvironmentCaptureError("shell_files_changed");
+        }
+        catch (error) {
+            const errorCode = error instanceof MachineEnvironmentCaptureError ? error.code : selected.source === "windows-registry" ? "windows_environment_unavailable" : "shell_capture_failed";
+            if (errorCode === "shell_cleanup_failed")
+                unsafeCleanup = true;
+            lastFailureTime = now();
+            return publish(lastGood?.env ?? baseline, { state: lastGood ? "stale" : "fallback", errorCode, attemptedAt });
+        }
+        finally {
+            capturing = false;
+        }
+    };
+    const acquire = (acquireOptions) => {
+        if (flight) {
+            if (acquireOptions?.force && !capturing) {
+                const requestedEpoch = captureEpoch;
+                forcedFollowup ??= flight.then((value) => captureEpoch > requestedEpoch ? value : acquire({ force: true })).finally(() => { forcedFollowup = undefined; });
+                return forcedFollowup;
+            }
+            return flight;
+        }
+        if (stopped || unsafeCleanup || selected.source === null)
+            return Promise.resolve(snapshot);
+        controller = new AbortController();
+        flight = refresh(acquireOptions?.force === true, controller.signal).finally(() => { flight = undefined; controller = undefined; });
+        return flight;
+    };
+    return {
+        acquire,
+        status: () => snapshot.status,
+        async stop() {
+            stopped = true;
+            controller?.abort();
+            await flight;
+        },
+    };
+}

package/dist/machine-environment-contract.js

@@ -0,0 +1,10 @@
+export class MachineEnvironmentCaptureError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "MachineEnvironmentCaptureError";
+    }
+}
+export const MACHINE_ENVIRONMENT_MAX_BYTES = 1024 * 1024;
+export const MACHINE_ENVIRONMENT_MAX_ENTRIES = 4096;

package/dist/machine-environment-control.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+const Request = z.object({ type: z.enum(["machine:environment:get", "machine:environment:refresh"]), reqId: z.string().min(1).max(200) }).strict();
+/** 发送回调由连接持有，刷新完成后不得把旧请求回复到新 socket。 */
+export async function handleMachineEnvironmentFrame(decoded, provider, send) {
+    if (typeof decoded !== "object" || decoded === null || !("type" in decoded)
+        || (decoded.type !== "machine:environment:get" && decoded.type !== "machine:environment:refresh"))
+        return false;
+    const reqId = "reqId" in decoded && typeof decoded.reqId === "string" ? decoded.reqId.slice(0, 200) : "invalid";
+    const reply = (result) => { try {
+        send({ type: "fs:result", reqId, ...result });
+    }
+    catch { /* 连接失效由服务端超时处理。 */ } };
+    const parsed = Request.safeParse(decoded);
+    if (!parsed.success) {
+        reply({ ok: false, error: "machine_environment_request_invalid" });
+        return true;
+    }
+    try {
+        if (parsed.data.type === "machine:environment:refresh")
+            await provider.acquire({ force: true });
+        reply({ ok: true, data: provider.status() });
+    }
+    catch {
+        reply({ ok: false, error: "machine_environment_request_failed" });
+    }
+    return true;
+}

package/dist/machine-environment-policy.js

@@ -0,0 +1,75 @@
+import { userInfo } from "node:os";
+import { basename, isAbsolute, join } from "node:path";
+import { MACHINE_ENVIRONMENT_MAX_BYTES, MACHINE_ENVIRONMENT_MAX_ENTRIES, MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+const ACCOUNT_KEYS = new Set(["HOME", "USER", "LOGNAME", "SHELL", "USERPROFILE", "USERNAME", "USERDOMAIN", "USERDOMAIN_ROAMINGPROFILE", "HOMEDRIVE", "HOMEPATH", "SYSTEMROOT", "WINDIR", "COMSPEC"]);
+const CONFIGURED_KEYS = new Set(["QA_REPORT_HUB", "QA_RUNTIME_ROOT", "QA_REPORT_DELIVERY_CONTEXT"]);
+export const isMachineControlKey = (key) => /^(CREW_|NOWWORK_)/iu.test(key);
+export const isMachineTransientKey = (key) => ["_", "SHLVL", "PWD", "OLDPWD"].includes(key) || key.startsWith("BASH_FUNC_");
+export function copyMachineEnvironment(env) {
+    return Object.freeze(Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string")));
+}
+export function resolveMachineAccount() {
+    const info = userInfo();
+    return Object.freeze({ home: info.homedir, username: info.username, shell: info.shell, uid: info.uid });
+}
+/** 账号来自操作系统，不受 daemon 的 profile HOME 或 rc 改写影响。 */
+export function restoreMachineEnvironmentOwnership(captured, startup, account, platform) {
+    const protectedKeys = new Set(Object.keys(startup).filter((key) => CONFIGURED_KEYS.has(key.toUpperCase())).map((key) => key.toUpperCase()));
+    const owns = (key) => isMachineControlKey(key) || ACCOUNT_KEYS.has(key.toUpperCase()) || protectedKeys.has(key.toUpperCase());
+    const entries = Object.entries(captured).filter(([key]) => !owns(key) && !isMachineTransientKey(key));
+    entries.push(...Object.entries(startup).filter(([key]) => owns(key)));
+    const env = Object.fromEntries(entries);
+    if (platform === "win32") {
+        for (const key of Object.keys(env))
+            if (["HOME", "USERPROFILE", "USERNAME"].includes(key.toUpperCase()))
+                delete env[key];
+        env.USERPROFILE = account.home;
+        env.USERNAME = account.username;
+        if (startup.HOME !== undefined)
+            env.HOME = account.home;
+    }
+    else {
+        env.HOME = account.home;
+        env.USER = account.username;
+        env.LOGNAME = account.username;
+        const shell = account.shell || startup.SHELL;
+        if (shell)
+            env.SHELL = shell;
+        else
+            delete env.SHELL;
+    }
+    return Object.freeze(env);
+}
+export function machineCaptureStartupEnvironment(startup, account, platform) {
+    const owned = restoreMachineEnvironmentOwnership(startup, startup, account, platform);
+    return Object.freeze(Object.fromEntries(Object.entries(owned).filter(([key]) => !isMachineControlKey(key) && !isMachineTransientKey(key))));
+}
+export function selectMachineEnvironmentSource(mode, account, startup, platform) {
+    if (mode === "off")
+        return { source: null };
+    if (platform === "win32")
+        return { source: mode === "auto" || mode === "windows" ? "windows-registry" : null };
+    if (mode === "windows")
+        return { source: null };
+    const loginShell = account.shell || startup.SHELL;
+    const name = mode === "auto" ? basename(loginShell ?? "") : mode;
+    if (name !== "bash" && name !== "zsh")
+        return { source: null };
+    const shellPath = loginShell && isAbsolute(loginShell) && basename(loginShell) === name ? loginShell : join("/bin", name);
+    return { source: name, shellPath };
+}
+export function validateMachineEnvironment(value, bytes) {
+    if (bytes !== undefined && bytes > MACHINE_ENVIRONMENT_MAX_BYTES)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new MachineEnvironmentCaptureError("shell_capture_failed");
+    const entries = Object.entries(value);
+    if (entries.length > MACHINE_ENVIRONMENT_MAX_ENTRIES)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    if (entries.some(([key, item]) => !key || key.includes("=") || key.includes("\0") || typeof item !== "string" || item.includes("\0"))) {
+        throw new MachineEnvironmentCaptureError("shell_capture_failed");
+    }
+    if (Buffer.byteLength(JSON.stringify(value), "utf8") > MACHINE_ENVIRONMENT_MAX_BYTES)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    return Object.freeze(Object.fromEntries(entries));
+}

package/dist/machine-environment-process.js

@@ -0,0 +1,110 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { MACHINE_ENVIRONMENT_MAX_BYTES, MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+/** 只接收本模块 detached spawn 所创建的进程组，绝不复用 supervisor 的 PID 清理接口。 */
+async function cleanupOwnedGroup(pid) {
+    const exists = () => {
+        try {
+            process.kill(-pid, 0);
+            return true;
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return false;
+            throw new MachineEnvironmentCaptureError("shell_cleanup_failed");
+        }
+    };
+    const signal = (value) => {
+        try {
+            process.kill(-pid, value);
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw new MachineEnvironmentCaptureError("shell_cleanup_failed");
+        }
+    };
+    if (!exists())
+        return;
+    for (const value of ["SIGTERM", "SIGKILL"]) {
+        signal(value);
+        const until = Date.now() + 1_000;
+        while (exists() && Date.now() < until)
+            await delay(20);
+        if (!exists())
+            return;
+    }
+    throw new MachineEnvironmentCaptureError("shell_cleanup_failed");
+}
+export async function runMachineEnvironmentProcess(options) {
+    if (options.signal.aborted || Date.now() >= options.deadline)
+        throw new MachineEnvironmentCaptureError("shell_capture_timeout");
+    const collectFd = options.collectFd;
+    const stdio = Array.from({ length: Math.max(3, (collectFd ?? 2) + 1, (options.metadataFd ?? 2) + 1) }, () => "ignore");
+    if (collectFd !== undefined)
+        stdio[collectFd] = "pipe";
+    if (options.metadataFd !== undefined)
+        stdio[options.metadataFd] = "pipe";
+    const child = spawn(options.file, [...options.args], { cwd: options.cwd, env: options.env, detached: true, stdio });
+    const chunks = [];
+    let size = 0;
+    const metadata = [];
+    let metadataSize = 0;
+    let timer;
+    let abort;
+    let cleanup;
+    const cleanupOnce = () => cleanup ??= child.pid === undefined ? Promise.resolve() : cleanupOwnedGroup(child.pid);
+    try {
+        return await new Promise((resolve, reject) => {
+            const fail = (code) => reject(new MachineEnvironmentCaptureError(code));
+            abort = () => fail("shell_capture_timeout");
+            options.signal.addEventListener("abort", abort, { once: true });
+            timer = setTimeout(abort, Math.max(0, options.deadline - Date.now()));
+            const channel = collectFd === undefined ? undefined : child.stdio[collectFd];
+            channel?.on("data", (chunk) => {
+                size += chunk.length;
+                if (size > (options.maxBytes ?? MACHINE_ENVIRONMENT_MAX_BYTES))
+                    fail("shell_capture_too_large");
+                else
+                    chunks.push(chunk);
+            });
+            channel?.on("error", () => fail("shell_capture_failed"));
+            const metadataChannel = options.metadataFd === undefined ? undefined : child.stdio[options.metadataFd];
+            metadataChannel?.on("data", (chunk) => {
+                metadataSize += chunk.length;
+                if (metadataSize > 16_384)
+                    fail("shell_capture_too_large");
+                else
+                    metadata.push(chunk);
+            });
+            metadataChannel?.on("error", () => fail("shell_capture_failed"));
+            child.once("error", () => fail("shell_unavailable"));
+            child.once("exit", () => {
+                // rc 的后台任务会继承 fd3；主进程退出即清理，不能等所有继承者自行 close。
+                void cleanupOnce().catch(() => fail("shell_cleanup_failed"));
+            });
+            child.once("close", (code) => {
+                if (code === 0) {
+                    options.onMetadata?.(Buffer.concat(metadata));
+                    resolve(Buffer.concat(chunks));
+                }
+                else
+                    fail(options.exitErrorCode ?? "shell_capture_failed");
+            });
+            if (options.signal.aborted)
+                abort();
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abort)
+            options.signal.removeEventListener("abort", abort);
+        try {
+            await cleanupOnce();
+        }
+        finally {
+            for (const stream of child.stdio)
+                stream?.destroy();
+        }
+    }
+}