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

package/dist/message-file-preview.js

@@ -0,0 +1,239 @@
+/**
+ * 消息授权后的按需单文件读取。Server 决定消息权限、原执行设备及项目 ID；
+ * 本模块只解析本机受控根、拒绝别名与越界，并有界读取，不持久化状态。
+ */
+import { constants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+import { isInternalEnvironmentPath } from "./workspace-fs.js";
+import { opaqueKey, safeKey } from "./workspace.js";
+import { AgentHandleSchema } from "./execution-protocol.js";
+const MAX_BYTES = 256 * 1024;
+const MAX_CONCURRENT_READS = 4;
+let activeReads = 0;
+export const SharedFileRequestSchema = z.object({
+    type: z.literal("fs:read-shared"),
+    reqId: z.string().min(1).max(128),
+    handle: AgentHandleSchema.refine((handle) => !handle.startsWith(".")),
+    path: z.string().min(1).max(4096),
+    fileContext: z.object({
+        taskKey: z.string().min(1).max(200),
+        projectIds: z.array(z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/)).max(100),
+        primaryProjectId: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/).optional(),
+    }).strict().refine((value) => !value.primaryProjectId || value.projectIds.includes(value.primaryProjectId)),
+}).strict();
+export class SharedFileError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "SharedFileError";
+    }
+}
+const inside = (root, target) => {
+    const rel = relative(root, target);
+    return rel === "" || (!isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`));
+};
+const parts = (path) => path.split(/[\\/]/).filter(Boolean);
+const privatePart = (part) => part.startsWith(".")
+    || /^(?:credentials?|secrets?|tokens?)(?:[._-]|$)/i.test(part)
+    || /^(?:id_rsa|id_ed25519|id_ecdsa|id_dsa|passwd|shadow|authorized_keys|known_hosts)$/i.test(part)
+    || /\.(?:pem|key|p12|pfx|keystore)$/i.test(part);
+function validatePath(path) {
+    // path 已由 Server 从 Markdown 解码，禁止再次解释编码、协议或设备路径。
+    if (/[\x00-\x1f\x7f]/.test(path) || /%[0-9a-f]{2}/i.test(path)
+        || path.startsWith("\\\\") || path.startsWith("//") || path.startsWith("~")
+        || parts(path).some((part) => part === "..")
+        || (process.platform !== "win32" && (/^[A-Za-z]:/.test(path) || path.includes("\\")))
+        || (process.platform === "win32" && path.slice(2).includes(":"))) {
+        throw new SharedFileError("file_not_viewable");
+    }
+}
+function restrictAgentTask(agentsRoot, agentRoot, path, taskNames) {
+    if (!inside(agentsRoot, path))
+        return;
+    if (!inside(agentRoot, path)) {
+        // 旧版托管项目位于 agentsRoot/repos；仍必须经过下方登记项目根检查。
+        if (inside(join(agentsRoot, "repos"), path))
+            return;
+        throw new SharedFileError("file_scope_unavailable");
+    }
+    const local = parts(relative(agentRoot, path));
+    const identity = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+    if (identity(local[0] ?? "") === "tasks" && (!local[1] || !taskNames.map(identity).includes(identity(local[1])))) {
+        throw new SharedFileError("file_scope_unavailable");
+    }
+}
+async function checkedCandidate(candidate) {
+    const rel = relative(candidate.root, candidate.path);
+    if (!inside(candidate.root, candidate.path) || parts(rel).some(privatePart) || isInternalEnvironmentPath(candidate.path)) {
+        throw new SharedFileError("file_not_viewable");
+    }
+    try {
+        const before = await lstat(candidate.root, { bigint: true });
+        if (!before.isDirectory())
+            throw new SharedFileError("file_not_viewable");
+        const root = await realpath(candidate.root);
+        if (isInternalEnvironmentPath(root))
+            throw new SharedFileError("file_not_viewable");
+        const [current, canonical] = await Promise.all([
+            lstat(candidate.root, { bigint: true }), lstat(root, { bigint: true }),
+        ]);
+        if (![current, canonical].every((entry) => entry.isDirectory() && entry.dev === before.dev && entry.ino === before.ino)) {
+            throw new SharedFileError("file_changed");
+        }
+        const path = resolve(root, rel);
+        await assertRegularPath(root, path);
+        return { root, path };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function assertRegularPath(root, target) {
+    let current = root;
+    const segments = parts(relative(root, target));
+    if (segments.length === 0)
+        throw new SharedFileError("file_not_viewable");
+    for (let index = 0; index < segments.length; index++) {
+        const segment = segments[index];
+        if (privatePart(segment))
+            throw new SharedFileError("file_not_viewable");
+        current = join(current, segment);
+        const entry = await lstat(current);
+        if (entry.isSymbolicLink())
+            throw new SharedFileError("file_not_viewable");
+        if (index < segments.length - 1 ? !entry.isDirectory() : !entry.isFile() || entry.nlink !== 1) {
+            throw new SharedFileError("file_not_viewable");
+        }
+    }
+    if (await realpath(target) !== target)
+        throw new SharedFileError("file_not_viewable");
+}
+async function resolveCandidate(agentsRoot, request, registry) {
+    const agentRoot = resolve(agentsRoot, request.handle);
+    // 根本身不能是符号链接；缺失任务文件由候选阶段归一为 file_not_found。
+    try {
+        if (!(await lstat(agentRoot)).isDirectory())
+            throw new SharedFileError("file_not_viewable");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const taskNames = [...new Set([opaqueKey(request.fileContext.taskKey), safeKey(request.fileContext.taskKey)])];
+    const taskRoots = taskNames.map((name) => join(agentRoot, "tasks", name));
+    let candidates;
+    if (isAbsolute(request.path)) {
+        const target = resolve(request.path);
+        restrictAgentTask(resolve(agentsRoot), agentRoot, target, taskNames);
+        if (inside(agentRoot, target)) {
+            candidates = [{ root: agentRoot, path: target }];
+        }
+        else {
+            const registrations = await registry.list().catch(() => []);
+            const roots = registrations.filter((project) => request.fileContext.projectIds.includes(project.projectId)
+                && isAbsolute(project.root) && resolve(project.root) !== parse(resolve(project.root)).root
+                && inside(resolve(project.root), target));
+            if (roots.length === 0)
+                throw new SharedFileError("file_scope_unavailable");
+            // 嵌套项目取最具体的已授权根；同一实际文件不构成相对路径歧义。
+            const root = roots.map((project) => resolve(project.root)).sort((a, b) => b.length - a.length)[0];
+            candidates = [{ root, path: target }];
+        }
+    }
+    else {
+        const rel = request.path.replace(/^\.\//, "");
+        if (parts(rel).some(privatePart))
+            throw new SharedFileError("file_not_viewable");
+        const target = resolve(agentRoot, rel);
+        restrictAgentTask(resolve(agentsRoot), agentRoot, target, taskNames);
+        candidates = [{ root: agentRoot, path: target }, ...taskRoots.map((root) => ({ root: agentRoot, path: resolve(root, rel) }))];
+    }
+    const resolved = (await Promise.all(candidates.map(checkedCandidate))).filter((v) => v !== null);
+    const unique = [...new Map(resolved.map((value) => [value.path, value])).values()];
+    if (unique.length === 0)
+        throw new SharedFileError("file_not_found");
+    if (unique.length !== 1)
+        throw new SharedFileError("file_path_ambiguous");
+    return unique[0];
+}
+async function readCandidate(candidate) {
+    const before = await lstat(candidate.path, { bigint: true });
+    // Darwin SDK sys/fcntl.h 的 O_NOFOLLOW_ANY 原子拒绝任何父目录符号链接。
+    // Node 尚未导出该常量；Linux 则在下方通过已打开句柄的真实路径核验。
+    // Darwin 不允许 O_NOFOLLOW_ANY 与 O_NOFOLLOW 同时使用。
+    const noFollow = process.platform === "darwin" ? 0x20000000 : (constants.O_NOFOLLOW ?? 0);
+    const handle = await open(candidate.path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | noFollow);
+    try {
+        const opened = await handle.stat({ bigint: true });
+        // 对照打开前身份并重新检查整条路径，拒绝检查与读取之间的替换。
+        if (!opened.isFile() || opened.nlink !== 1n || opened.dev !== before.dev || opened.ino !== before.ino) {
+            throw new SharedFileError("file_changed");
+        }
+        await assertRegularPath(candidate.root, candidate.path);
+        if (process.platform === "linux" && await realpath(`/proc/self/fd/${handle.fd}`) !== candidate.path) {
+            throw new SharedFileError("file_changed");
+        }
+        const current = await lstat(candidate.path, { bigint: true });
+        if (current.dev !== opened.dev || current.ino !== opened.ino || !current.isFile() || current.nlink !== 1n) {
+            throw new SharedFileError("file_changed");
+        }
+        const buffer = Buffer.alloc(MAX_BYTES);
+        let length = 0;
+        while (length < buffer.length) {
+            const read = await handle.read(buffer, length, buffer.length - length, length);
+            if (read.bytesRead === 0)
+                break;
+            length += read.bytesRead;
+        }
+        const after = await handle.stat({ bigint: true });
+        const currentAfter = await lstat(candidate.path, { bigint: true });
+        if (after.size !== opened.size || after.mtimeNs !== opened.mtimeNs || after.ctimeNs !== opened.ctimeNs
+            || currentAfter.dev !== opened.dev || currentAfter.ino !== opened.ino || !currentAfter.isFile()) {
+            throw new SharedFileError("file_changed");
+        }
+        const bytes = buffer.subarray(0, length);
+        if (bytes.includes(0))
+            throw new SharedFileError("file_binary");
+        const truncated = opened.size > BigInt(length);
+        let content;
+        try {
+            content = new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: truncated });
+        }
+        catch {
+            throw new SharedFileError("file_binary");
+        }
+        return { path: relative(candidate.root, candidate.path).split(sep).join("/"), content, size: Number(opened.size), truncated };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readSharedMessageFile(agentsRoot, rawRequest, registry) {
+    const parsed = SharedFileRequestSchema.safeParse(rawRequest);
+    if (!parsed.success)
+        throw new SharedFileError("file_not_viewable");
+    if (process.platform !== "darwin" && process.platform !== "linux")
+        throw new SharedFileError("file_scope_unavailable");
+    validatePath(parsed.data.path);
+    if (activeReads >= MAX_CONCURRENT_READS)
+        throw new SharedFileError("file_preview_busy");
+    activeReads++;
+    try {
+        return await readCandidate(await resolveCandidate(agentsRoot, parsed.data, registry));
+    }
+    catch (error) {
+        if (error instanceof SharedFileError)
+            throw error;
+        if (error.code === "ENOENT")
+            throw new SharedFileError("file_not_found");
+        throw new SharedFileError("file_not_viewable");
+    }
+    finally {
+        activeReads--;
+    }
+}

package/dist/provider-env.js

@@ -10,6 +10,7 @@
  */
 import { join } from "node:path";
 import { DEEPSEEK_CODEX_KEY_ENV, deepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
+import { mergeRuntimeEnvironments } from "./runtime-environment-merge.js";
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -56,11 +57,12 @@ const CONFLICTING_CODEX_ENV = [
     DEEPSEEK_CODEX_KEY_ENV,
 ];
 /** 返回叠加了 provider 隔离的新 env(不改入参);不支持的 runtime/provider 组合原样返回。 */
-export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverride) {
+export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverride, platform = process.platform) {
     if (runtime === "codex" && cfg.provider === "deepseek") {
         const env = { ...base };
-        for (const key of CONFLICTING_CODEX_ENV)
-            delete env[key];
+        for (const key of Object.keys(env))
+            if (CONFLICTING_CODEX_ENV.includes(platform === "win32" ? key.toUpperCase() : key))
+                delete env[key];
         env.CODEX_HOME = deepSeekHomeOverride ?? deepSeekCodexHome(homeDir);
         if (cfg.providerApiKey)
             env[DEEPSEEK_CODEX_KEY_ENV] = cfg.providerApiKey;
@@ -72,8 +74,9 @@ export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverri
     if (runtime !== "claude" || cfg.provider !== "custom")
         return base;
     const env = { ...base };
-    for (const k of CONFLICTING_ENV)
-        delete env[k];
+    for (const key of Object.keys(env))
+        if (CONFLICTING_ENV.includes(platform === "win32" ? key.toUpperCase() : key))
+            delete env[key];
     if (cfg.providerBaseUrl)
         env.ANTHROPIC_BASE_URL = cfg.providerBaseUrl;
     if (cfg.providerApiKey) {
@@ -91,20 +94,31 @@ export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverri
         env.ANTHROPIC_SMALL_FAST_MODEL = cfg.providerSmallFastModel;
         env.ANTHROPIC_DEFAULT_HAIKU_MODEL = cfg.providerSmallFastModel;
     }
-    return env;
+    return mergeRuntimeEnvironments([env], platform);
+}
+const deepSeekHarnessMachineOwnedKey = (key, platform) => {
+    const identity = platform === "win32" ? key.toUpperCase() : key;
+    return identity.startsWith("DEEPSEEK_") || identity.startsWith("NOWCREW_DEEPSEEK_HARNESS_") || identity.startsWith("DSH_");
+};
+/** 子命令切换目录后仍必须保留 provider 的鉴权/路由边界，包括被清除的键。 */
+export function providerOwnedEnvironmentKeys(runtime, cfg, candidateKeys, platform = process.platform) {
+    if (runtime === "claude" && cfg.provider === "custom")
+        return [...CONFLICTING_ENV, "CLAUDE_CONFIG_DIR"];
+    if (runtime === "codex" && cfg.provider === "deepseek")
+        return CONFLICTING_CODEX_ENV;
+    if (runtime === "deepseek-harness")
+        return candidateKeys.filter(key => deepSeekHarnessMachineOwnedKey(key, platform));
+    return [];
 }
-const deepSeekHarnessMachineOwnedKey = (key) => (key.toUpperCase().startsWith("DEEPSEEK_")
-    || key.toUpperCase().startsWith("NOWCREW_DEEPSEEK_HARNESS_")
-    || key.toUpperCase().startsWith("DSH_"));
 /** Agent env remains available to tools, but cannot replace Harness process policy or credentials. */
-export function applyDeepSeekHarnessMachineEnv(base, machineEnv) {
+export function applyDeepSeekHarnessMachineEnv(base, machineEnv, platform = process.platform) {
     const env = { ...base };
     for (const key of Object.keys(env)) {
-        if (deepSeekHarnessMachineOwnedKey(key))
+        if (deepSeekHarnessMachineOwnedKey(key, platform))
             delete env[key];
     }
     for (const [key, value] of Object.entries(machineEnv)) {
-        if (deepSeekHarnessMachineOwnedKey(key) && value !== undefined)
+        if (deepSeekHarnessMachineOwnedKey(key, platform) && value !== undefined)
             env[key] = value;
     }
     return env;

package/dist/runner.js

@@ -1,3 +1,4 @@
+import { createMachineEnvironmentProvider } from "./machine-environment-cache.js";
 /** Legacy agent orchestration around the business-neutral local executor. */
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
@@ -24,6 +25,18 @@ function runtimeName(value) {
     throw new Error(`unsupported runtime: ${value}`);
 }
 export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
+    const owned = dependencies.machineEnvironment === undefined;
+    const machineEnvironment = dependencies.machineEnvironment
+        ?? createMachineEnvironmentProvider({ mode: config.machineEnvironmentMode ?? "off" });
+    try {
+        return await runAgentWithMachineEnvironment(config, input, onActivity, onConsole, { ...dependencies, machineEnvironment });
+    }
+    finally {
+        if (owned)
+            await machineEnvironment.stop();
+    }
+}
+async function runAgentWithMachineEnvironment(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
     const threadId = input.scheduled ? undefined : input.threadId;
     const taskAnchor = threadId ?? input.wakeMessageId;
     // Old servers have no typed maintenance purpose. A legacy marker can only
@@ -118,6 +131,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         onRuntimeStarting: () => dependencies.onRuntimePhase?.("starting", runtime),
         onRuntimeRunning: () => dependencies.onRuntimePhase?.("running", runtime),
     }, {
+        ...(dependencies.machineEnvironment === undefined ? {} : { machineEnvironment: dependencies.machineEnvironment }),
         launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
         ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
         ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),

package/dist/runtime-environment-merge.js

@@ -0,0 +1,16 @@
+/** Keep layer order authoritative even when Windows keys use different casing. */
+export function mergeRuntimeEnvironments(layers, platform = process.platform) {
+    const entries = new Map();
+    for (const layer of layers) {
+        for (const [key, value] of Object.entries(layer)) {
+            if (value !== undefined)
+                entries.set(platform === "win32" ? key.toUpperCase() : key, [key, value]);
+        }
+    }
+    return Object.fromEntries(entries.values());
+}
+export function runtimeEnvironmentValue(env, key, platform = process.platform) {
+    if (platform !== "win32")
+        return env?.[key];
+    return Object.entries(env ?? {}).find(([candidate]) => candidate.toUpperCase() === key.toUpperCase())?.[1];
+}

package/dist/runtime-health-handler.js

@@ -3,3 +3,13 @@ export const runtimeHealthProbeHandler = (configuredProbe, executionRuntimesKnow
     ...(executionRuntimesKnown ? { availableRuntimes: detectedExecutionRuntimes } : {}),
 }));
 export const handleRuntimeHealthProbeFrame = (decoded, configuredProbe, executionRuntimesKnown, detectedExecutionRuntimes) => handleRuntimeProbeFrame(decoded, runtimeHealthProbeHandler(configuredProbe, executionRuntimesKnown, detectedExecutionRuntimes));
+/** 将探针结果按既有 RPC 帧返回，serve 只保留路由选择。 */
+export async function replyRuntimeHealthProbe(decoded, configuredProbe, known, runtimes, send) {
+    const result = await handleRuntimeHealthProbeFrame(decoded, configuredProbe, known, runtimes);
+    if (result !== null) {
+        try {
+            send({ type: "fs:result", ...result });
+        }
+        catch { /* Server 查询超时处理断连 */ }
+    }
+}

package/dist/runtime-health.js

@@ -123,7 +123,9 @@ export async function probeRuntimeHealth(request, dependencies = {}) {
     const now = dependencies.now ?? (() => new Date());
     const monotonicNow = dependencies.monotonicNow ?? (() => performance.now());
     const sourceEnv = dependencies.env ?? process.env;
-    const env = { ...sourceEnv, PATH: augmentedPath(sourceEnv) };
+    const env = dependencies.env === undefined
+        ? { ...sourceEnv, PATH: augmentedPath(sourceEnv) }
+        : { ...sourceEnv };
     const availableRuntimes = dependencies.availableRuntimes ?? parsed.availableRuntimes;
     const results = [];
     for (const target of parsed.runtimes) {

package/dist/runtime-path.js

@@ -8,24 +8,27 @@
  */
 import { existsSync } from "node:fs";
 import { win32, posix } from "node:path";
+import { runtimeEnvironmentValue } from "./runtime-environment-merge.js";
 const pathApi = (platform) => (platform === "win32" ? win32 : posix);
 /** 该平台常见 CLI 安装目录候选(是否真实存在稍后由 augmentedPath 校验)。 */
 export function commonBinDirs(env = process.env, platform = process.platform) {
     const p = pathApi(platform);
+    const value = (key) => runtimeEnvironmentValue(env, key, platform);
     if (platform === "win32") {
         const dirs = [];
-        if (env.USERPROFILE) {
-            dirs.push(p.join(env.USERPROFILE, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
-            p.join(env.USERPROFILE, ".local", "bin"));
+        const userProfile = value("USERPROFILE"), appData = value("APPDATA"), localAppData = value("LOCALAPPDATA");
+        if (userProfile) {
+            dirs.push(p.join(userProfile, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+            p.join(userProfile, ".local", "bin"));
         }
-        if (env.APPDATA)
-            dirs.push(p.join(env.APPDATA, "npm"));
-        if (env.LOCALAPPDATA)
-            dirs.push(p.join(env.LOCALAPPDATA, "Microsoft", "WindowsApps"));
+        if (appData)
+            dirs.push(p.join(appData, "npm"));
+        if (localAppData)
+            dirs.push(p.join(localAppData, "Microsoft", "WindowsApps"));
         return dirs;
     }
     const dirs = [];
-    const home = env.HOME;
+    const home = value("HOME");
     if (home) {
         dirs.push(p.join(home, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
         p.join(home, ".local", "bin"), // Claude 官方原生安装器默认落点
@@ -41,19 +44,26 @@ export function commonBinDirs(env = process.env, platform = process.platform) {
  * 在 `env.PATH` 基础上,把候选目录里「真实存在且尚未在 PATH 中」的去重后 prepend,返回新的 PATH 字符串。
  * 用户装的目录优先命中(prepend);全部已存在或都不在磁盘上时,原样返回 `env.PATH`。
  */
-export function augmentedPath(env = process.env, deps = {}, platform = process.platform) {
+export function augmentedPath(env = process.env, deps = {}, platform = process.platform, placement = "prepend") {
     const dirExists = deps.dirExists ?? existsSync;
     const sep = pathApi(platform).delimiter;
-    const current = env.PATH ?? "";
-    const existing = new Set(current.split(sep).filter((entry) => entry.length > 0));
+    const current = runtimeEnvironmentValue(env, "PATH", platform) ?? "";
+    const keyOf = (entry) => platform === "win32" ? entry.replace(/\//gu, "\\").toLowerCase() : entry;
+    const currentEntries = current.split(sep).filter((entry) => entry.length > 0);
+    const existing = new Set(currentEntries.map(keyOf));
     const extra = [];
     for (const dir of commonBinDirs(env, platform)) {
-        if (existing.has(dir) || extra.includes(dir))
+        if (existing.has(keyOf(dir)) || extra.some(entry => keyOf(entry) === keyOf(dir)))
             continue;
         if (!dirExists(dir))
             continue;
         extra.push(dir);
     }
+    if (placement === "append") {
+        const seen = new Set();
+        return [...currentEntries, ...extra].filter(entry => { const key = keyOf(entry); if (seen.has(key))
+            return false; seen.add(key); return true; }).join(sep);
+    }
     if (extra.length === 0)
         return current;
     return current.length > 0 ? `${extra.join(sep)}${sep}${current}` : extra.join(sep);

package/dist/runtime-probe.js

@@ -9,8 +9,8 @@ export function createRuntimeProbeCoordinator() {
     const abort = new AbortController();
     const flights = new Map();
     return {
-        detect(installed, detector, connectionId) {
-            const key = [...installed].sort().join("\0");
+        detect(installed, detector, connectionId, environmentGeneration = "") {
+            const key = JSON.stringify([environmentGeneration, [...installed].sort()]);
             const existing = flights.get(key);
             const probeId = existing?.probeId ?? randomUUID();
             const fields = { probe_id: probeId, connection_id: connectionId, installed_runtimes: JSON.stringify(installed) };

package/dist/runtimes/claude-models.js

@@ -14,6 +14,7 @@ import { tmpdir } from "node:os";
 import { createInterface } from "node:readline";
 import { promisify } from "node:util";
 import { isWin } from "../platform.js";
+import { augmentedPath } from "../runtime-path.js";
 const execFileP = promisify(execFile);
 const PROBE_TIMEOUT_MS = 8_000;
 // 本机丢弃端口:连不上也无所谓,init 事件在任何网络请求之前就已输出。
@@ -26,18 +27,27 @@ const CLAUDE_ALIASES = [
 ];
 const DEFAULT_ALIAS = "sonnet";
 const cacheByVersion = new Map();
+let cacheByEnvironment = new WeakMap();
 /** "2.1.258 (Claude Code)" → "2.1.258";空/异常输出 → ""。 */
 export function normalizeClaudeVersion(raw) {
     return raw.replace(/\s*\(Claude Code\)\s*$/, "").trim();
 }
-export async function listClaudeModels(deps = defaultDeps) {
-    const version = normalizeClaudeVersion(await deps.probeVersion());
-    const cached = version ? cacheByVersion.get(version) : undefined;
+export async function listClaudeModels(deps, env, environmentGeneration = "") {
+    const probes = deps ?? { probeVersion: () => probeVersion(env), resolveAlias: (alias) => resolveAlias(alias, env) };
+    let cache = env ? cacheByEnvironment.get(env) : cacheByVersion;
+    if (!cache) {
+        cache = new Map();
+        if (env)
+            cacheByEnvironment.set(env, cache);
+    }
+    const version = normalizeClaudeVersion(await probes.probeVersion());
+    const cacheKey = JSON.stringify([environmentGeneration, version]);
+    const cached = version ? cache.get(cacheKey) : undefined;
     if (cached)
         return cached;
     const resolved = await Promise.all(CLAUDE_ALIASES.map(async ([alias]) => {
         try {
-            return await deps.resolveAlias(alias);
+            return await probes.resolveAlias(alias);
         }
         catch {
             return null;
@@ -53,22 +63,24 @@ export async function listClaudeModels(deps = defaultDeps) {
         };
     });
     if (version && resolved.every((model) => model !== null))
-        cacheByVersion.set(version, models);
+        cache.set(cacheKey, models);
     return models;
 }
 /** 仅测试用:清空版本缓存。 */
 export function resetClaudeModelCache() {
     cacheByVersion.clear();
+    cacheByEnvironment = new WeakMap();
 }
-async function probeVersion() {
+async function probeVersion(env = { ...process.env, PATH: augmentedPath() }) {
     const { stdout } = await execFileP("claude", ["--version"], {
         shell: isWin(),
         timeout: PROBE_TIMEOUT_MS,
         killSignal: "SIGKILL",
+        env,
     });
     return stdout;
 }
-function resolveAlias(alias) {
+function resolveAlias(alias, env = { ...process.env, PATH: augmentedPath() }) {
     return new Promise((resolve) => {
         const child = spawn("claude", [
             "--model", alias,
@@ -78,7 +90,7 @@ function resolveAlias(alias) {
         ], {
             cwd: tmpdir(),
             env: {
-                ...process.env,
+                ...env,
                 ANTHROPIC_BASE_URL: UNROUTABLE_API_BASE,
                 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
             },
@@ -120,4 +132,3 @@ export function initModelOf(line) {
         return null;
     }
 }
-const defaultDeps = { probeVersion, resolveAlias };

package/dist/runtimes/deepseek-harness.js

@@ -1,19 +1,21 @@
 import spawn from "cross-spawn";
-import { isAbsolute } from "node:path";
+import { isAbsolute, win32, join } from "node:path";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { deepSeekHarnessLaunch } from "./deepseek-harness-launch.js";
 import { prepareHarnessProfile } from "./deepseek-harness-profile.js";
 import { probeKimiAcp, AcpProbeCleanupError } from "./kimi-acp-runner.js";
+import { runtimeEnvironmentValue } from "../runtime-environment-merge.js";
+import { augmentedPath } from "../runtime-path.js";
 export const DEEPSEEK_HARNESS_CONFIG_ENV = "NOWCREW_DEEPSEEK_HARNESS_CONFIG";
 export const DEEPSEEK_HARNESS_PATCH_ENV = "NOWCREW_DEEPSEEK_HARNESS_PATCH";
-export function deepSeekHarnessLauncher(env = process.env) {
-    const configPath = env[DEEPSEEK_HARNESS_CONFIG_ENV]?.trim();
-    const patchPath = env[DEEPSEEK_HARNESS_PATCH_ENV]?.trim();
-    if (configPath && !isAbsolute(configPath))
+export function deepSeekHarnessLauncher(env = process.env, platform = process.platform) {
+    const configPath = runtimeEnvironmentValue(env, DEEPSEEK_HARNESS_CONFIG_ENV, platform)?.trim();
+    const patchPath = runtimeEnvironmentValue(env, DEEPSEEK_HARNESS_PATCH_ENV, platform)?.trim();
+    const absolute = platform === "win32" ? win32.isAbsolute : isAbsolute;
+    if (configPath && !absolute(configPath))
         throw new Error(`${DEEPSEEK_HARNESS_CONFIG_ENV} must be an absolute path`);
-    if (patchPath && !isAbsolute(patchPath))
+    if (patchPath && !absolute(patchPath))
         throw new Error(`${DEEPSEEK_HARNESS_PATCH_ENV} must be an absolute path`);
     if (configPath && patchPath)
         throw new Error("DeepSeek Harness legacy config and profile patch are mutually exclusive");
@@ -21,24 +23,27 @@ export function deepSeekHarnessLauncher(env = process.env) {
         ? { kind: "legacy", bin: "dsh-acp-demo", configPath }
         : { kind: "profile", bin: "dsh", ...(patchPath ? { patchPath } : {}) };
 }
-export function deepSeekHarnessConfigPath(env = process.env) {
-    const path = env[DEEPSEEK_HARNESS_CONFIG_ENV]?.trim();
-    return path && isAbsolute(path) ? path : null;
+export function deepSeekHarnessConfigPath(env = process.env, platform = process.platform) {
+    const path = runtimeEnvironmentValue(env, DEEPSEEK_HARNESS_CONFIG_ENV, platform)?.trim();
+    return path && (platform === "win32" ? win32.isAbsolute(path) : isAbsolute(path)) ? path : null;
 }
 /** The published DeepSeek Harness ACP executable speaks JSON-RPC directly on stdio. */
 export async function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
     if (options.signal?.aborted)
         return false;
+    const sourceEnv = options.env ?? { ...process.env, PATH: augmentedPath() };
     let root;
     try {
         const launcher = options.configPath === undefined
-            ? deepSeekHarnessLauncher()
+            ? deepSeekHarnessLauncher(sourceEnv)
             : deepSeekHarnessLauncher({
+                ...sourceEnv,
                 [DEEPSEEK_HARNESS_CONFIG_ENV]: options.configPath,
             });
         if (launcher.kind === "legacy")
             return await probeKimiAcp({
                 ...options,
+                env: sourceEnv,
                 provider: "deepseek-harness",
                 configPath: launcher.configPath,
                 effectivePermission: "sandboxed",
@@ -50,7 +55,7 @@ export async function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
             systemPrompt: "",
             skillRoots: [],
             effectivePermission: "sandboxed",
-            env: process.env,
+            env: sourceEnv,
             ...(launcher.patchPath ? { patchPath: launcher.patchPath } : {}),
         });
         const launch = deepSeekHarnessLaunch(options.bin, profile.args);

package/dist/runtimes/hermes-models.js

@@ -71,9 +71,10 @@ async function stopChild(child) {
 }
 export async function listHermesModels(options = {}) {
     const spawnProcess = options.spawnProcess ?? spawn;
+    const env = options.env ?? { ...process.env, PATH: augmentedPath() };
     const child = spawnProcess("hermes", ["acp"], {
         cwd: process.cwd(),
-        env: { ...process.env, PATH: augmentedPath() },
+        env,
         stdio: ["pipe", "pipe", "pipe"],
     });
     if (child.stdin === null || child.stdout === null || child.stderr === null)