@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/machine-info.js

@@ -1,7 +1,11 @@
+import { retryHarnessProbe } from "./runtimes/harness-probe-retry.js";
+import { MARKETPLACE_CAPABILITY } from "./marketplace-protocol.js";
 /**
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
  * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
  */
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { hostname, arch, platform as osPlatform } from "node:os";
 import { lookupCmd } from "./platform.js";
 import { augmentedPath } from "./runtime-path.js";
@@ -14,11 +18,11 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
-import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./runtimes/kimi-acp-runner.js";
 import { probeHermesAcp } from "./runtimes/hermes.js";
 import { probeOpenCodeRun } from "./runtimes/opencode.js";
 import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
-import { probeDeepSeekHarnessAcp } from "./runtimes/deepseek-harness.js";
+import { probeDeepSeekHarnessAcp, deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
 import { daemonHome } from "./computer-profile.js";
 import { daemonReleaseProvenance } from "./release-provenance.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
@@ -28,17 +32,20 @@ export const TRAINING_PROJECT_DEPENDENCIES_CAPABILITY = "training_project_depend
 export const SELF_TRAINING_EXECUTION_CAPABILITY = "self_training_execution_v1";
 export const EXECUTION_LARGE_ATTACHMENTS_CAPABILITY = "execution_attachments_300m_v1";
 export const PROJECT_SKILL_PROJECTION_CAPABILITY = "project_skill_projection_v2";
+export const MACHINE_ENVIRONMENT_CAPABILITY = "machine_environment_v1";
 export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
     resolverReady: true,
     nativeRuntimeAdaptersReady: true,
 });
 export const DAEMON_CAPABILITIES = Object.freeze([
+    MARKETPLACE_CAPABILITY,
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
     "execution_telemetry_ack_v1",
     "execution_external_output_v1",
     "execution_attachments_v1",
+    "message_file_preview_v1",
     EXECUTION_LARGE_ATTACHMENTS_CAPABILITY,
     "execution_answer_stream_v1",
     "execution_machine_queue_v1",
@@ -53,6 +60,8 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "agent_ability_release_v1",
     "agent_ability_workspace_v1",
     "agent_ability_runtime_assets_v1",
+    "agent_environments_v1",
+    MACHINE_ENVIRONMENT_CAPABILITY,
 ]);
 /** 能力只按平台过滤,进程存活期间静态(CLAUDE.md 红线)。Windows 在 junction/copy 真机 smoke 通过前不宣告 Project Skills。 */
 export const daemonCapabilities = (runtimePlatform = process.platform, readiness = NATIVE_PROJECT_WORKSPACE_READINESS) => {
@@ -61,7 +70,9 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     const nativeWorkspaceReady = nativeWorkspacePlatform
         && readiness.resolverReady
         && readiness.nativeRuntimeAdaptersReady;
-    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
+    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== MARKETPLACE_CAPABILITY || nativeWorkspacePlatform)
+        && (capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
+        && (capability !== "message_file_preview_v1" || nativeWorkspacePlatform)
         && (nativeWorkspacePlatform
             || (capability !== "project_skills_v1"
                 && capability !== "project_skill_projection_v2"
@@ -90,15 +101,15 @@ const RUNTIME_BINS = [
     ["gemini", "gemini"],
     ["hermes", "hermes"],
     ["opencode", "opencode"],
-    ["deepseek-harness", "dsh-acp-demo"],
+    ["deepseek-harness", "dsh"],
     ["copilot", "copilot"],
     ["kimi", "kimi"],
     ["pi", "pi"],
 ];
-async function isInstalled(bin) {
+async function isInstalled(bin, env) {
     try {
         // 用增强 PATH 探测:daemon 继承的 PATH 可能缺 ~/.local/bin 等用户级目录(Claude 原生安装器落点)。
-        await execFileP(lookupCmd(), [bin], { env: { ...process.env, PATH: augmentedPath() } });
+        await execFileP(lookupCmd(), [bin], { env });
         return true;
     }
     catch {
@@ -106,30 +117,65 @@ async function isInstalled(bin) {
     }
 }
 /** 并发探测所有候选 runtime,返回已安装的展示名列表。 */
-export async function detectRuntimes() {
-    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
+export async function detectRuntimes(env = { ...process.env, PATH: augmentedPath() }) {
+    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => {
+        try {
+            return await isInstalled(name === "deepseek-harness" ? deepSeekHarnessLauncher(env).bin : bin, env) ? name : null;
+        }
+        catch {
+            return null;
+        }
+    }));
     return checks.filter((x) => x !== null);
 }
-async function supportsKimiAcp(signal) {
-    return probeKimiAcp({ bin: "kimi", ...(signal ? { signal } : {}) });
+async function supportsKimiAcp(signal, probeId, env) {
+    return probeKimiAcp({ bin: "kimi", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}), ...(env ? { env } : {}) });
 }
-async function supportsHermesAcp(signal) {
-    return probeHermesAcp({ bin: "hermes", ...(signal ? { signal } : {}) });
+async function supportsHermesAcp(signal, probeId, env) {
+    return probeHermesAcp({ bin: "hermes", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}), ...(env ? { env } : {}) });
 }
-async function supportsOpenCodeRun(signal) {
-    return probeOpenCodeRun(signal);
+async function supportsOpenCodeRun(signal, _probeId, env) {
+    return probeOpenCodeRun(signal, env);
 }
-async function supportsDeepSeekHarnessAcp(signal) {
-    return probeDeepSeekHarnessAcp({ bin: "dsh-acp-demo", ...(signal ? { signal } : {}) });
+async function supportsDeepSeekHarnessAcp(signal, probeId, env) {
+    try {
+        return await probeDeepSeekHarnessAcp({ bin: deepSeekHarnessLauncher(env).bin, ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}), ...(env ? { env } : {}) });
+    }
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
+        return false;
+    }
 }
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal, probeId = randomUUID()) {
     const present = await installed;
+    const probe = (runtime, detect) => {
+        const startedAt = Date.now();
+        dslog("runtime_probe.optional_start", "开始可选 runtime 探测", { probe_id: probeId, runtime, aborted: signal?.aborted ?? false });
+        const complete = (outcome, ready) => {
+            dslog("runtime_probe.optional_complete", "可选 runtime 探测结束", {
+                probe_id: probeId, runtime, outcome, duration_ms: Date.now() - startedAt,
+                aborted: signal?.aborted ?? false, ...(ready === undefined ? {} : { ready }),
+            });
+        };
+        let pending;
+        try {
+            pending = detect(signal, probeId);
+        }
+        catch (error) {
+            complete("threw");
+            throw error;
+        }
+        return pending.then((ready) => { complete("resolved", ready); return ready; }, (error) => { complete("threw"); throw error; });
+    };
     const [kimiReady, hermesReady, openCodeReady, deepSeekHarnessReady] = await Promise.all([
-        present.includes("kimi") ? kimiAcpProbe(signal) : false,
-        present.includes("hermes") ? hermesAcpProbe(signal) : false,
-        present.includes("opencode") ? openCodeProbe(signal) : false,
-        present.includes("deepseek-harness") ? deepSeekHarnessProbe(signal) : false,
+        present.includes("kimi") ? probe("kimi", kimiAcpProbe) : false,
+        present.includes("hermes") ? probe("hermes", hermesAcpProbe) : false,
+        present.includes("opencode") ? probe("opencode", openCodeProbe) : false,
+        present.includes("deepseek-harness")
+            ? retryHarnessProbe(() => probe("deepseek-harness", deepSeekHarnessProbe), signal, probeId)
+            : false,
     ]);
     return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
         : runtime === "hermes" ? hermesReady
@@ -137,7 +183,7 @@ export async function detectExecutionRuntimes(installed = detectRuntimes(), kimi
                 : runtime === "deepseek-harness" ? deepSeekHarnessReady
                     : true));
 }
-export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal);
+export const detectExecutionRuntimesWithSignal = (installed, signal, probeId, env) => detectExecutionRuntimes(installed, (probeSignal, id) => supportsKimiAcp(probeSignal, id, env), (probeSignal, id) => supportsHermesAcp(probeSignal, id, env), (probeSignal, id) => supportsOpenCodeRun(probeSignal, id, env), (probeSignal, id) => supportsDeepSeekHarnessAcp(probeSignal, id, env), signal, probeId);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -174,13 +220,13 @@ async function listAgentHandles(agentsRoot) {
 }
 export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform, dependencies = {}) {
     const [runtimes, agentHandles, additionalCapabilities] = await Promise.all([
-        (dependencies.detectInstalled ?? detectRuntimes)(),
+        (dependencies.detectInstalled ?? (() => detectRuntimes(dependencies.env)))(),
         listAgentHandles(agentsRoot),
         dependencies.additionalCapabilities?.() ?? Promise.resolve([]),
     ]);
     const backend = executionBackendCapability(runtimePlatform, dependencies.jobObjectProbe);
     const executionRuntimes = backend.supported
-        ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
+        ? await (dependencies.detectExecutable ?? ((installed) => detectExecutionRuntimesWithSignal(installed, undefined, undefined, dependencies.env)))(runtimes)
         : [];
     const baseCapabilities = dependencies.capabilities ?? daemonCapabilities(runtimePlatform);
     const capabilities = additionalCapabilities.length === 0 && Object.isFrozen(baseCapabilities)
@@ -203,7 +249,6 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         runtimes,
         executionRuntimes,
         capabilities,
-        ...(dependencies.codexHomeMode === undefined ? {} : { codexHomeMode: dependencies.codexHomeMode }),
         ...(dependencies.profileName === undefined ? {} : {
             layoutVersion: 1,
             profileName: dependencies.profileName,

package/dist/machine-runtime-environment.js

@@ -0,0 +1,189 @@
+import { WebSocket } from "ws";
+import { createMachineEnvironmentProvider, createStaticMachineEnvironmentProvider } from "./machine-environment-cache.js";
+import { copyMachineEnvironment } from "./machine-environment-policy.js";
+import { collectMachineHello, detectRuntimes, detectExecutionRuntimesWithSignal } from "./machine-info.js";
+import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator } from "./runtime-probe.js";
+import { augmentedPath } from "./runtime-path.js";
+import { mergeRuntimeEnvironments, runtimeEnvironmentValue } from "./runtime-environment-merge.js";
+import { listRuntimeModels } from "./list-models.js";
+import { handleRuntimeProbeFrame, probeRuntimeHealth } from "./runtime-health.js";
+import { dslog } from "./slog.js";
+const version = (snapshot) => `${snapshot.status.bootId}:${snapshot.status.generation}`;
+/** 启动 hello 不等待 shell；每次成功环境代次以独立探测和连接围栏更新运行能力。 */
+export function createMachineRuntimeEnvironment(options) {
+    const startupEnv = copyMachineEnvironment(options.startupEnv ?? process.env);
+    let stopped = false;
+    let connection;
+    let cycle;
+    let accepted;
+    let latest;
+    let stopPromise;
+    let warmed = false;
+    const retiredBoots = new Set();
+    const preparedEnvironments = new WeakMap();
+    const prepare = (snapshot) => {
+        const existing = preparedEnvironments.get(snapshot.env);
+        if (existing)
+            return existing;
+        const source = { ...snapshot.env, PATH: runtimeEnvironmentValue(snapshot.env, "PATH") ?? "" };
+        const env = Object.freeze(mergeRuntimeEnvironments([snapshot.env, { PATH: augmentedPath(source, {}, process.platform, "append") }]));
+        preparedEnvironments.set(snapshot.env, env);
+        return env;
+    };
+    const current = (candidate) => !stopped && cycle === candidate
+        && connection === candidate.connection && connection.socket.readyState === WebSocket.OPEN
+        && version(latest) === version(candidate.snapshot);
+    const inactiveReason = (candidate) => connection !== candidate.connection
+        ? "stale_connection" : candidate.connection.socket.readyState !== WebSocket.OPEN
+        ? "socket_not_open" : "stale_environment";
+    const refreshRuntimes = () => {
+        if (stopped || !connection || connection.socket.readyState !== WebSocket.OPEN)
+            return;
+        cycle?.probe.stop();
+        const next = { connection, snapshot: latest, probe: createRuntimeProbeCoordinator(), facts: Promise.resolve([]), runtimes: [], known: false };
+        cycle = next;
+        const env = prepare(next.snapshot);
+        const collect = options.machineInfo?.collect ?? collectMachineHello;
+        const helloPromise = collect(options.config.agentsRoot, options.config.executionLimits, process.platform, {
+            env,
+            detectInstalled: () => (options.machineInfo?.detectInstalled ?? detectRuntimes)(env),
+            detectExecutable: async (installed) => conservativeExecutionRuntimes(installed),
+            additionalCapabilities: options.additionalCapabilities,
+            capabilities: next.connection.capabilities,
+            ...(options.profileName === undefined ? {} : { profileName: options.profileName }),
+        });
+        next.facts = helloPromise.then(async (hello) => {
+            if (!current(next))
+                return [];
+            next.runtimes = hello.executionRuntimes;
+            const initialPublished = next.connection.beforePublish.then(() => {
+                if (current(next))
+                    options.publish(hello, next.connection.socket);
+            });
+            const logDecision = (reason, runtimes) => dslog("runtime_probe.hello_refresh", "runtime hello 刷新决策", {
+                connection_id: next.connection.connectionId, reason, current_socket: connection === next.connection,
+                socket_open: next.connection.socket.readyState === WebSocket.OPEN, socket_ready_state: next.connection.socket.readyState,
+                installed_runtimes: JSON.stringify(hello.runtimes), initial_execution_runtimes: JSON.stringify(hello.executionRuntimes),
+                execution_runtimes: JSON.stringify(runtimes), environment_boot_id: next.snapshot.status.bootId, environment_generation: next.snapshot.status.generation,
+            });
+            if (hello.executionProtocol === undefined) {
+                next.known = true;
+                logDecision("protocol_unavailable", []);
+                await initialPublished;
+                return [];
+            }
+            const detector = options.machineInfo?.detectExecutable ?? detectExecutionRuntimesWithSignal;
+            const detected = await next.probe.detect(hello.runtimes, (installed, signal, probeId) => detector(installed, signal, probeId, env), next.connection.connectionId, version(next.snapshot));
+            if (!current(next)) {
+                logDecision(inactiveReason(next), detected);
+                return [];
+            }
+            next.runtimes = detected;
+            next.known = true;
+            await initialPublished;
+            const changed = JSON.stringify(detected) !== JSON.stringify(hello.executionRuntimes);
+            logDecision(!current(next) ? inactiveReason(next) : changed ? "publish" : "unchanged", detected);
+            if (current(next) && changed)
+                options.publish({ ...hello, executionRuntimes: [...detected] }, next.connection.socket);
+            return detected;
+        }).catch(() => {
+            if (current(next)) {
+                next.known = true;
+                options.onError("runtime_detection_failed", {
+                    reason: "detection_threw", ...(next.connection.connectionId === undefined ? {} : { connection_id: next.connection.connectionId }),
+                    current_socket: connection === next.connection, socket_open: next.connection.socket.readyState === WebSocket.OPEN,
+                });
+            }
+            return [];
+        });
+    };
+    const observe = (snapshot) => {
+        if (stopped)
+            return;
+        if (snapshot.status.state !== "ready") {
+            // 预热可先给出账号归属已恢复的基线；loading/disabled 本身不触发重新探测。
+            if (!accepted && !connection)
+                latest = snapshot;
+            return;
+        }
+        if (accepted) {
+            if (retiredBoots.has(snapshot.status.bootId))
+                return;
+            if (snapshot.status.bootId === accepted.status.bootId && snapshot.status.generation <= accepted.status.generation)
+                return;
+            if (snapshot.status.bootId !== accepted.status.bootId)
+                retiredBoots.add(accepted.status.bootId);
+        }
+        accepted = snapshot;
+        latest = snapshot;
+        refreshRuntimes();
+    };
+    const source = options.provider ?? (options.config.machineEnvironmentMode === undefined || options.config.machineEnvironmentMode === "off"
+        ? createStaticMachineEnvironmentProvider(startupEnv)
+        : createMachineEnvironmentProvider({ startupEnv, mode: options.config.machineEnvironmentMode, onChange: observe }));
+    latest = Object.freeze({ env: startupEnv, status: source.status() });
+    const stop = () => {
+        if (stopPromise)
+            return stopPromise;
+        stopped = true;
+        cycle?.probe.stop();
+        connection = undefined;
+        stopPromise = Promise.resolve().then(() => source.stop()).catch(() => { throw new Error("machine_environment_stop_failed"); });
+        return stopPromise;
+    };
+    const provider = {
+        async acquire(input) { if (stopped)
+            return latest; const snapshot = await source.acquire(input); observe(snapshot); return snapshot; },
+        status: () => source.status(), stop,
+    };
+    return {
+        provider,
+        prewarm: () => {
+            if (stopped || warmed)
+                return;
+            warmed = true;
+            void provider.acquire().catch(() => { if (!stopped)
+                options.onError("machine_environment_capture_failed"); });
+        },
+        open: (socket, input) => { connection = { socket, ...input }; refreshRuntimes(); },
+        close: (socket) => { if (connection?.socket === socket) {
+            connection = undefined;
+            cycle?.probe.stop();
+            cycle = undefined;
+        } },
+        async availableRuntimes(runtime) {
+            while (!stopped && cycle) {
+                const active = cycle;
+                if (active.runtimes.includes(runtime))
+                    return active.runtimes;
+                await active.facts;
+                if (cycle === active)
+                    return active.runtimes;
+            }
+            return [];
+        },
+        async models(runtime) {
+            const snapshot = await provider.acquire();
+            if (stopped || version(latest) !== version(snapshot))
+                throw new Error("runtime_environment_changed");
+            const models = await (options.models ?? listRuntimeModels)(runtime, { env: prepare(snapshot), environmentGeneration: version(snapshot) });
+            if (stopped || version(latest) !== version(snapshot))
+                throw new Error("runtime_environment_changed");
+            return models;
+        },
+        async health(decoded, probe = probeRuntimeHealth) {
+            return handleRuntimeProbeFrame(decoded, async (request) => {
+                const snapshot = await provider.acquire();
+                if (stopped || version(latest) !== version(snapshot))
+                    throw new Error("runtime_environment_changed");
+                const active = cycle;
+                const known = active?.known === true && version(active.snapshot) === version(snapshot);
+                const result = await probe(request, { env: prepare(snapshot), ...(known ? { availableRuntimes: active.runtimes } : {}) });
+                if (stopped || version(latest) !== version(snapshot))
+                    throw new Error("runtime_environment_changed");
+                return result;
+            });
+        },
+        stop,
+    };
+}

package/dist/machine-shell-environment-capture.js

@@ -0,0 +1,135 @@
+import { access, lstat, realpath, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+import { isMachineTransientKey, machineCaptureStartupEnvironment, validateMachineEnvironment } from "./machine-environment-policy.js";
+import { runMachineEnvironmentProcess } from "./machine-environment-process.js";
+const quote = (value) => `'${value.replace(/'/gu, `'"'"'`)}'`;
+const ENV_PROGRAM = 'require("node:fs").writeFileSync(3,JSON.stringify(process.env))';
+/** stderr 只在私有有界管道中短暂保留；返回实际入口路径，不返回 trace 或错误文本。 */
+async function tracedZshEntrypoints(bytes, accountHome) {
+    if (!bytes)
+        throw new MachineEnvironmentCaptureError("shell_capture_failed");
+    const entries = new Set();
+    for (const line of bytes.toString("utf8").split("\n")) {
+        if (!line.endsWith("<sourcetrace>"))
+            continue;
+        const match = /^(.*):\d+> <sourcetrace>$/u.exec(line);
+        // 自定义 PS4 隐藏了来源时无法证明入口，不能把未检查的半份环境发布为 ready。
+        if (!match?.[1] || match[1].includes("\0"))
+            throw new MachineEnvironmentCaptureError("shell_capture_failed");
+        // printf >&2 可不换行。只接受原生 +path:line> 尾部中唯一真实入口，
+        // 不能把前缀噪声（可能含秘密）拼进 sourceLocations。
+        const starts = [...match[1].matchAll(/\+/gu)].map((part) => part.index + 1);
+        if (starts.length === 0 || starts.length > 32)
+            throw new MachineEnvironmentCaptureError("shell_capture_failed");
+        const paths = [...new Set(starts.map((start) => resolve(accountHome, match[1].slice(start))))]
+            .filter((path) => /\/(?:\.zshenv|\.zshrc)$/u.test(path)
+            || ["/etc/zshenv", "/etc/zsh/zshenv", "/etc/zshrc", "/etc/zsh/zshrc"].includes(path));
+        if (paths.length === 0)
+            continue;
+        const existing = (await Promise.all(paths.map(async (path) => {
+            try {
+                return (await stat(path)).isFile() ? path : null;
+            }
+            catch {
+                return null;
+            }
+        }))).filter((path) => path !== null);
+        if (existing.length !== 1)
+            throw new MachineEnvironmentCaptureError("shell_files_changed");
+        entries.add(existing[0]);
+    }
+    return [...entries];
+}
+export function machineShellSourceLocations(request, effectiveDirectory) {
+    if (request.source === "bash")
+        return [join(request.account.home, ".bashrc")];
+    if (request.source !== "zsh")
+        return [];
+    const initial = resolve(request.account.home, request.startupEnv.ZDOTDIR ?? request.account.home);
+    const effective = effectiveDirectory ?? initial;
+    return [...new Set(["/etc/zshenv", "/etc/zsh/zshenv", "/etc/zshrc", "/etc/zsh/zshrc", join(initial, ".zshenv"), join(initial, ".zshrc"), join(effective, ".zshrc")])].slice(0, 8);
+}
+export async function machineEnvironmentSourceFingerprint(locations) {
+    return JSON.stringify(await Promise.all(locations.map(async (path) => {
+        try {
+            const link = await lstat(path);
+            const target = await stat(path);
+            return [path, link.dev, link.ino, link.mtimeMs, link.ctimeMs, link.size, await realpath(path), target.dev, target.ino, target.mtimeMs, target.ctimeMs, target.size];
+        }
+        catch (error) {
+            if (["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+                return [path, "missing"];
+            throw new MachineEnvironmentCaptureError("shell_capture_failed");
+        }
+    })));
+}
+export const captureShellMachineEnvironment = async (request) => {
+    if (request.source !== "bash" && request.source !== "zsh")
+        throw new MachineEnvironmentCaptureError("shell_unavailable");
+    const file = request.shellPath;
+    if (!file || !isAbsolute(file))
+        throw new MachineEnvironmentCaptureError("shell_unavailable");
+    try {
+        await access(file, constants.X_OK);
+    }
+    catch {
+        throw new MachineEnvironmentCaptureError("shell_unavailable");
+    }
+    const env = machineCaptureStartupEnvironment(request.startupEnv, request.account, process.platform);
+    const processOptions = { file, env, cwd: request.account.home, signal: request.signal, deadline: request.deadline };
+    const syntaxCheck = async (path) => {
+        try {
+            await access(path, constants.R_OK);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw new MachineEnvironmentCaptureError("shell_capture_failed");
+        }
+        await runMachineEnvironmentProcess({ ...processOptions, args: request.source === "bash" ? ["--noprofile", "--norc", "-n", path] : ["-f", "-n", path], exitErrorCode: "shell_syntax_invalid" });
+    };
+    let locations = machineShellSourceLocations(request);
+    if (request.source === "bash")
+        await syntaxCheck(join(request.account.home, ".bashrc"));
+    const command = `${request.source === "zsh" ? "[[ -o sourcetrace ]] || exit 73; " : ""}exec ${quote(process.execPath)} -e ${quote(ENV_PROGRAM)}`;
+    const args = request.source === "zsh" ? ["-o", "SOURCE_TRACE", "-ic", command] : ["--noprofile", "--rcfile", join(request.account.home, ".bashrc"), "-ic", command];
+    for (let discovery = 0; discovery < 2; discovery++) {
+        const before = await machineEnvironmentSourceFingerprint(locations);
+        let sourceTraceBytes;
+        const bytes = await runMachineEnvironmentProcess({ ...processOptions, args, collectFd: 3, ...(request.source === "zsh" ? { metadataFd: 2, onMetadata: (value) => { sourceTraceBytes = value; } } : {}) });
+        if (before !== await machineEnvironmentSourceFingerprint(locations))
+            throw new MachineEnvironmentCaptureError("shell_files_changed");
+        if (request.source === "zsh") {
+            const actualEntrypoints = await tracedZshEntrypoints(sourceTraceBytes, request.account.home);
+            sourceTraceBytes = undefined;
+            const discovered = actualEntrypoints.some((path) => !locations.includes(path));
+            const nextLocations = [...new Set([...locations, ...actualEntrypoints])];
+            if (nextLocations.length > 8)
+                throw new MachineEnvironmentCaptureError("shell_capture_failed");
+            const actualBefore = await machineEnvironmentSourceFingerprint(nextLocations);
+            for (const path of actualEntrypoints)
+                await syntaxCheck(path);
+            if (actualBefore !== await machineEnvironmentSourceFingerprint(nextLocations))
+                throw new MachineEnvironmentCaptureError("shell_files_changed");
+            if (discovered) {
+                if (discovery > 0)
+                    throw new MachineEnvironmentCaptureError("shell_files_changed");
+                // 新发现的入口在本次执行前没有指纹；丢弃发现轮，按原截止时间重采一次。
+                locations = nextLocations;
+                continue;
+            }
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            throw new MachineEnvironmentCaptureError("shell_capture_failed");
+        }
+        const exported = validateMachineEnvironment(parsed, bytes.length);
+        return { env: Object.freeze(Object.fromEntries(Object.entries(exported).filter(([key]) => !isMachineTransientKey(key)))), sourceLocations: locations };
+    }
+    throw new MachineEnvironmentCaptureError("shell_files_changed");
+};