@nowcrew/daemon 0.6.79-beta.2 → 0.6.80-beta.1

package/dist/local-executor.js

@@ -32,6 +32,8 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
+import { machinePackageManagerEnv, packageManagerEnvFacts } from "./package-manager-env.js";
+import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
@@ -49,15 +51,6 @@ const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
 const CODEX_COLLABORATION_EXEC_WARNING = "codex_collaboration_disabled_on_exec";
-const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const RESERVED_ENV = new Set([
-    "PATH",
-    "XDG_CONFIG_HOME",
-    "XDG_DATA_HOME",
-    "XDG_CACHE_HOME",
-    "GH_CONFIG_DIR",
-    "CLOUDSDK_CONFIG",
-]);
 function withoutClaudeInstructionFlag(env) {
     if (!(CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV in env))
         return env;
@@ -68,14 +61,6 @@ function withoutClaudeInstructionFlag(env) {
 const warnRuntimeLocally = (code) => {
     process.stderr.write(`[runtime-warning] ${code}\n`);
 };
-export function sanitizeEnvVars(raw) {
-    if (!raw)
-        return {};
-    return Object.fromEntries(Object.entries(raw).filter(([key, value]) => typeof value === "string"
-        && ENV_KEY_RE.test(key)
-        && !key.toUpperCase().startsWith("CREW_")
-        && !RESERVED_ENV.has(key.toUpperCase())));
-}
 export function awaitExit(child) {
     return new Promise((resolve) => {
         let settled = false;
@@ -461,6 +446,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const baseEnv = {
             ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
+            ...(input.trainingProjectContext === undefined
+                ? {}
+                : machinePackageManagerEnv(inheritedEnv)),
             ...input.launch.systemEnv,
             PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,
             CREW_SERVER_URL: input.launch.serverUrl,
@@ -503,6 +491,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             qa_runtime_root: childEnv.QA_RUNTIME_ROOT ?? null,
             qa_runtime_root_present: childEnv.QA_RUNTIME_ROOT !== undefined,
             inherited_qa_runtime_root_present: inheritedEnv.QA_RUNTIME_ROOT !== undefined,
+            ...packageManagerEnvFacts(childEnv),
             training_root: join(workspace.dir, "training"),
             project_context_present: input.projectContext !== undefined,
             project_ids: JSON.stringify(input.projectContext === undefined

package/dist/package-manager-env.js

@@ -0,0 +1,75 @@
+import { readFileSync } from "node:fs";
+function nonEmpty(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized === "" ? undefined : normalized;
+}
+function registryUrl(value) {
+    const normalized = nonEmpty(value);
+    if (normalized === undefined)
+        return undefined;
+    try {
+        const protocol = new URL(normalized).protocol;
+        return protocol === "http:" || protocol === "https:" ? normalized : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function configuredPath(env) {
+    const explicit = env.CREW_PACKAGE_MANAGER_USERCONFIG?.trim();
+    if (explicit !== undefined && explicit !== "")
+        return explicit;
+    return undefined;
+}
+function registryFromNpmrc(path) {
+    if (path === undefined)
+        return undefined;
+    try {
+        const line = readFileSync(path, "utf8")
+            .split(/\r?\n/u)
+            .find((entry) => /^\s*registry\s*=/u.test(entry));
+        return registryUrl(line?.replace(/^\s*registry\s*=\s*/u, ""));
+    }
+    catch {
+        return undefined;
+    }
+}
+function npmrcHasAuth(path) {
+    if (path === undefined)
+        return false;
+    try {
+        return /^\s*(?:(?:\/\/[^=\s]+:)?_(?:auth|authToken|password))\s*=/imu.test(readFileSync(path, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Keep machine-owned npm credentials available for explicitly authorized
+ * training dependency installs. The daemon must opt in with
+ * CREW_PACKAGE_MANAGER_USERCONFIG; Agent env cannot reach this path.
+ */
+export function machinePackageManagerEnv(env = process.env) {
+    const npmUserConfig = configuredPath(env);
+    const yarnRegistry = npmUserConfig === undefined
+        ? undefined
+        : registryUrl(env.YARN_REGISTRY) ?? registryFromNpmrc(npmUserConfig);
+    const entries = npmUserConfig === undefined
+        ? []
+        : [["NPM_CONFIG_USERCONFIG", npmUserConfig]];
+    const alwaysAuth = npmrcHasAuth(npmUserConfig) ? "true" : undefined;
+    return Object.fromEntries(yarnRegistry === undefined && alwaysAuth === undefined
+        ? entries
+        : [
+            ...entries,
+            ...(yarnRegistry === undefined ? [] : [["YARN_REGISTRY", yarnRegistry]]),
+            ...(alwaysAuth === undefined ? [] : [["NPM_CONFIG_ALWAYS_AUTH", alwaysAuth]]),
+        ]);
+}
+export function packageManagerEnvFacts(env) {
+    return {
+        npm_userconfig_present: Boolean(env.NPM_CONFIG_USERCONFIG?.trim()),
+        yarn_registry_present: Boolean(env.YARN_REGISTRY?.trim()),
+        npm_always_auth_present: Boolean(env.NPM_CONFIG_ALWAYS_AUTH?.trim()),
+    };
+}

package/dist/runner.js

@@ -11,7 +11,8 @@ import { readOriginDecisionFile, resetOriginDecisionFile } from "./origin-decisi
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 import { launchSupervisedRuntime } from "./supervised-runtime.js";
 import { awaitWithCancellation, } from "./runtime-cancellation.js";
-export { awaitExit, exitActivity, sanitizeEnvVars } from "./local-executor.js";
+export { awaitExit, exitActivity } from "./local-executor.js";
+export { sanitizeEnvVars } from "./runtime-env.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
     claiming: "📌", crew: "⚙️", tool: "🛠️", tool_result: "↩️", done: "✅", error: "❌",

package/dist/runtime-env.js

@@ -0,0 +1,21 @@
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export const RESERVED_ENV = new Set([
+    "PATH",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+    "GH_CONFIG_DIR",
+    "CLOUDSDK_CONFIG",
+    "NPM_CONFIG_USERCONFIG",
+    "YARN_REGISTRY",
+    "NPM_CONFIG_ALWAYS_AUTH",
+]);
+/** 用户自定义环境只能补充普通变量,不能覆盖 daemon 维护的运行时契约。 */
+export function sanitizeEnvVars(raw) {
+    if (!raw)
+        return {};
+    return Object.fromEntries(Object.entries(raw).filter(([key, value]) => typeof value === "string"
+        && ENV_KEY_RE.test(key)
+        && !key.toUpperCase().startsWith("CREW_")
+        && !RESERVED_ENV.has(key.toUpperCase())));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.79-beta.2",
+  "version": "0.6.80-beta.1",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,6 +16,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
+    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
     "@nowcrew/cli": "0.4.13",
@@ -36,12 +44,5 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
-  },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/project-skills/capability.js

@@ -1,109 +0,0 @@
-import { PROJECT_SKILLS_CAPABILITY, PROJECT_SKILL_PROJECTION_V2_CAPABILITY, } from "./types.js";
-export function projectSkillV2RolloutReady(platform, readiness) {
-    const platformReady = platform === "darwin"
-        || platform === "linux"
-        || (platform === "win32" && readiness.nativeWindowsSmokePassed);
-    return platformReady
-        && readiness.runtimeRootStorePrimitiveReady
-        && readiness.runtimeRootStoreRecoveryReady
-        && readiness.leaseRecoveryReady
-        && readiness.controllerReady
-        && readiness.executionHandlerReady
-        && readiness.codexAdapterReady
-        && readiness.claudeAdapterReady;
-}
-export function effectiveProjectSkillCapabilities(capabilities, projectSkillsReady, projectSkillV2Ready) {
-    const projectSkillCapabilitiesReady = projectSkillsReady && projectSkillV2Ready;
-    if (!projectSkillCapabilitiesReady
-        && !capabilities.includes(PROJECT_SKILLS_CAPABILITY)
-        && !capabilities.includes(PROJECT_SKILL_PROJECTION_V2_CAPABILITY)
-        && Object.isFrozen(capabilities))
-        return capabilities;
-    const filtered = capabilities.filter((capability) => capability !== PROJECT_SKILL_PROJECTION_V2_CAPABILITY
-        && (projectSkillCapabilitiesReady || capability !== PROJECT_SKILLS_CAPABILITY));
-    if (!projectSkillCapabilitiesReady || !filtered.includes(PROJECT_SKILLS_CAPABILITY)) {
-        return Object.freeze(filtered);
-    }
-    const v1Index = filtered.indexOf(PROJECT_SKILLS_CAPABILITY);
-    return Object.freeze([
-        ...filtered.slice(0, v1Index + 1),
-        PROJECT_SKILL_PROJECTION_V2_CAPABILITY,
-        ...filtered.slice(v1Index + 1),
-    ]);
-}
-export function withProjectSkillCapabilityStatus(value, status) {
-    return {
-        ...value,
-        projectSkillsStatus: status,
-        capabilities: status === "ready"
-            ? value.capabilities
-            : effectiveProjectSkillCapabilities(value.capabilities, false, false),
-    };
-}
-const settleReadinessGate = async (operation) => {
-    try {
-        return await operation() === true;
-    }
-    catch {
-        return false;
-    }
-};
-export async function createProjectSkillConnectionCapabilitySnapshot(input) {
-    const runtimeRootStorePrimitiveReady = await settleReadinessGate(input.probeRuntimeRootStorePrimitive);
-    const controllerReady = await settleReadinessGate(input.initializeController);
-    const recoveryReady = await settleReadinessGate(input.recoverRuntimeRootsAndLeases);
-    const readiness = Object.freeze({
-        runtimeRootStorePrimitiveReady,
-        runtimeRootStoreRecoveryReady: recoveryReady,
-        leaseRecoveryReady: recoveryReady,
-        controllerReady,
-        executionHandlerReady: true,
-        codexAdapterReady: true,
-        claudeAdapterReady: true,
-        nativeWindowsSmokePassed: false,
-    });
-    const projectSkillsReady = projectSkillV2RolloutReady(input.platform, readiness);
-    return Object.freeze({
-        capabilities: effectiveProjectSkillCapabilities(input.baseCapabilities, projectSkillsReady, projectSkillsReady),
-        projectSkillsReady,
-        readiness,
-    });
-}
-export async function prepareProjectSkillConnectionCapabilities(input) {
-    const snapshot = await createProjectSkillConnectionCapabilitySnapshot({
-        ...input,
-        baseCapabilities: [...input.baseCapabilities, ...await input.additionalCapabilities()],
-    });
-    input.applyReadiness(snapshot.projectSkillsReady);
-    return snapshot.capabilities;
-}
-export function createProjectSkillControllerReadiness(input) {
-    let status = "initializing";
-    let initialization = null;
-    const ensure = () => {
-        if (status === "ready")
-            return Promise.resolve(true);
-        if (initialization !== null)
-            return initialization;
-        status = "initializing";
-        const attempt = input.initialize().then(() => {
-            status = "ready";
-            return true;
-        }, (error) => {
-            status = "unavailable";
-            input.onUnavailable(error);
-            return false;
-        }).finally(() => {
-            if (initialization === attempt)
-                initialization = null;
-            input.onSettled();
-        });
-        initialization = attempt;
-        return attempt;
-    };
-    return Object.freeze({
-        status: () => status,
-        ensure,
-        applyPreflight: (ready) => { status = ready ? "ready" : "unavailable"; },
-    });
-}

package/dist/project-skills/controller-convergence.js

@@ -1,57 +0,0 @@
-import { ProjectProjectionError, } from "./reconciler.js";
-export const MAX_REMEMBERED_PROJECT_SKILL_AGENTS = 64;
-const compareBinary = (left, right) => {
-    if (left < right)
-        return -1;
-    if (left > right)
-        return 1;
-    return 0;
-};
-const copySnapshot = (snapshot) => Object.freeze({
-    bindings: Object.freeze(snapshot.bindings.map((binding) => Object.freeze({ ...binding }))),
-    generation: snapshot.generation,
-});
-export function createProjectSkillSnapshotEpoch(maxEntries = MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
-    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
-        throw new ProjectProjectionError("skill_projection_failed");
-    }
-    const snapshots = new Map();
-    return Object.freeze({
-        begin() {
-            snapshots.clear();
-        },
-        remember(handle, snapshot) {
-            const previous = snapshots.get(handle);
-            if (previous !== undefined && snapshot.generation < previous.generation)
-                return;
-            if (previous === undefined && snapshots.size >= maxEntries) {
-                throw new ProjectProjectionError("skill_projection_failed");
-            }
-            snapshots.set(handle, copySnapshot(snapshot));
-        },
-        forget(handle) {
-            snapshots.delete(handle);
-        },
-        entries() {
-            return Object.freeze([...snapshots.entries()]
-                .sort(([left], [right]) => compareBinary(left, right))
-                .map(([handle, snapshot]) => Object.freeze([handle, copySnapshot(snapshot)])));
-        },
-    });
-}
-const stableErrorCode = (reason) => reason?.code === "skill_projection_snapshot_corrupt"
-    ? "skill_projection_snapshot_corrupt"
-    : "skill_projection_failed";
-export function toPathPrivateConvergenceResults(entries, results) {
-    return Object.freeze(entries.map(([handle], index) => {
-        const result = results[index];
-        if (result?.status === "fulfilled") {
-            return Object.freeze({ handle, status: "fulfilled" });
-        }
-        return Object.freeze({
-            handle,
-            status: "rejected",
-            errorCode: stableErrorCode(result?.reason),
-        });
-    }));
-}