@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/local-memory/work-log.js

@@ -0,0 +1,58 @@
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { safeKey } from "../workspace.js";
+/** 收尾会话可以换目录，但仍应消费同一任务已写好的日志；不迁移文件或复用会话。 */
+export async function resolveMemoryPruneWorkLog(workspace, input) {
+    // 旧映射有损时无法证明是同一任务，不能用它查找或清理来源。
+    if (input.keyMode !== "opaque" || !input.taskKey || safeKey(input.taskKey) !== input.taskKey) {
+        return workspace;
+    }
+    const legacyPath = join(workspace.dir, "tasks", input.taskKey, "work-log.md");
+    if (legacyPath === workspace.workLogPath)
+        return workspace;
+    let legacyStat;
+    try {
+        legacyStat = await lstat(legacyPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return workspace;
+        throw error;
+    }
+    if (!legacyStat.isFile() || legacyStat.isSymbolicLink()
+        || await realpath(legacyPath) !== join(await realpath(workspace.dir), "tasks", input.taskKey, "work-log.md")) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const workLog = await readFile(legacyPath, "utf8");
+    if (workLog.length === 0)
+        return workspace;
+    if ((await readFile(workspace.workLogPath, "utf8")).length > 0) {
+        throw new Error("local_memory_work_log_source_conflict");
+    }
+    return { ...workspace, workLogPath: legacyPath, workLog };
+}
+export function workLogSha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+/** 调用方须在同任务的提交互斥边界内校验；指纹对应实际注入模型的那一版内容。 */
+export async function verifyWorkLogSource(agentDir, path, expectedSha256) {
+    if (expectedSha256 === undefined)
+        throw new Error("local_memory_work_log_version_missing");
+    const relativePath = relative(resolve(agentDir), resolve(path));
+    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const before = await lstat(path);
+    if (!before.isFile() || before.isSymbolicLink()
+        || await realpath(path) !== join(await realpath(agentDir), relativePath)) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const content = await readFile(path);
+    const after = await lstat(path);
+    if (workLogSha256(content) !== expectedSha256 || before.dev !== after.dev || before.ino !== after.ino
+        || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+        throw new Error("local_memory_work_log_source_changed");
+    }
+    return after;
+}

package/dist/local-memory/write.js

@@ -2,29 +2,12 @@ import { createHash, randomUUID } from "node:crypto";
 import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
-import { containsLikelySecret } from "../agent-memory/policy.js";
-import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
+import { dslog } from "../slog.js";
+import { LocalMemoryChangeSchema, LocalMemorySingleLineText, validateLocalMemoryChange, } from "./candidate.js";
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, selectLocalMemoryIndexEntries, } from "./index-budget.js";
 import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
-const CategorySchema = z.enum([
-    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
-]);
-const SingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
-const ChangeSchema = z.object({
-    operation: z.enum(["create", "update", "supersede"]),
-    memoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    baseRevision: z.number().int().nonnegative().nullable(),
-    supersedesMemoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    title: SingleLineText.max(120),
-    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
-    summary: SingleLineText,
-    triggers: z.array(SingleLineText.max(80)).min(1).max(16),
-    priority: z.enum(["high", "medium", "low"]),
-    detailCategory: CategorySchema,
-    detailBody: z.string().trim().min(1).max(12_000),
-    reviewAfter: SingleLineText.nullable(),
-}).strict();
 const StatusChangeSchema = z.object({
-    memoryId: SingleLineText,
+    memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
     expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
     targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
@@ -35,7 +18,7 @@ const ResultSchema = z.object({
     purpose: z.literal("memory_prune"),
     baseCatalogRevision: z.number().int().nonnegative(),
     outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
-    changes: z.array(ChangeSchema).max(50),
+    changes: z.array(LocalMemoryChangeSchema).max(50),
     statusChanges: z.array(StatusChangeSchema).max(50),
 }).strict();
 const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
@@ -43,8 +26,6 @@ const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
 const NEXT_SECTION = /^##\s+(?!#)/mu;
 const CARD_HEADING = /^###\s+(.+?)\s*$/gmu;
 const FIELD_LINE = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
-const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
-const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
 function codePointLength(value) {
     return Array.from(value).length;
 }
@@ -117,13 +98,6 @@ function parseUnmarkedMemoryIndex(memory) {
     const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
     return parseCards(section);
 }
-function renderGeneratedIndex(entries) {
-    const cards = entries
-        .filter((entry) => entry.status === "pinned" || entry.status === "active")
-        .map(renderLocalMemoryIndexCard)
-        .join("\n");
-    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
-}
 function replaceGeneratedIndex(memory, entries) {
     const generated = renderGeneratedIndex(entries);
     if (GENERATED_INDEX_PATTERN.test(memory))
@@ -135,9 +109,15 @@ function replaceGeneratedIndex(memory, entries) {
     }
     return `${memory.trimEnd()}\n\n## Knowledge Index\n${generated}\n`;
 }
+function unwrappedNoteBody(title, body) {
+    const detail = body.trim();
+    const heading = /^([^\r\n]+)\r?\n\r?\n/u.exec(detail);
+    // Agent 可能回传包含包装标题的全文；只解开一层，保留内部及历史标题。
+    return heading?.[1] === `## ${title}` ? detail.slice(heading[0].length) : detail;
+}
 function noteSection(id, revision, title, body) {
     return `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} revision=${revision} -->\n`
-        + `## ${title}\n\n${body.trim()}\n`
+        + `## ${title}\n\n${unwrappedNoteBody(title, body)}\n`
         + `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->\n`;
 }
 function notePattern(id) {
@@ -148,34 +128,12 @@ function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
     return pattern.test(content) ? content.replace(pattern, replacement) : null;
 }
-function containsReservedText(change) {
-    return RESERVED_MEMORY_MARKER.test([change.title, change.summary, ...change.triggers, change.detailBody].join("\n"));
-}
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
         throw new Error("local_memory_no_change_has_operations");
     }
-    for (const change of result.changes) {
-        const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
-        if (containsLikelySecret(text))
-            throw new Error("local_memory_secret_candidate");
-        if (CONTROL_CHARACTER_PATTERN.test(text))
-            throw new Error("local_memory_control_character");
-        if (containsReservedText(change))
-            throw new Error("local_memory_reserved_marker");
-        if (change.operation === "create"
-            && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_create_revision_invalid");
-        }
-        if (change.operation === "update"
-            && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_update_revision_missing");
-        }
-        if (change.operation === "supersede"
-            && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
-            throw new Error("local_memory_supersede_revision_missing");
-        }
-    }
+    for (const change of result.changes)
+        validateLocalMemoryChange(change);
 }
 export function parseLocalMemoryResult(raw) {
     let value;
@@ -477,7 +435,16 @@ export async function applyLocalMemoryResult(input) {
         // Pending create candidates are durable overflow, not dead ends. Promote only
         // when the current catalog has room; supersede/update candidates stay pending
         // until a fresh revision-aware decision can safely replay them.
-        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+            if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
+                throw error;
+            // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
+            dslog("local_memory.pending_promotion_skipped", "pending目录超出扫描预算，本轮跳过自动提升", {
+                level: "WARN", execution_id: input.executionId, prune_trace_id: input.pruneTraceId,
+                reason: "memory_pending_directory_over_budget",
+            });
+            return [];
+        });
         for (const pending of pendingCandidatesOnDisk) {
             const change = pending.candidate;
             if (change.operation !== "create")
@@ -494,8 +461,10 @@ export async function applyLocalMemoryResult(input) {
             if (duplicate !== undefined) {
                 const duplicatePath = resolve(input.agentDir, duplicate.file);
                 const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
-                if (duplicateBody === change.detailBody)
+                if (duplicateBody === change.detailBody
+                    || duplicateBody === unwrappedNoteBody(change.title, change.detailBody).trim()) {
                     resolvedPendingIds.add(pending.pendingId);
+                }
                 continue;
             }
             const entry = entryFromChange(change, id, 1, "active");

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();
+        }
+    }
+}