@nowcrew/daemon 0.6.16 → 0.6.17

package/dist/project-workspaces/resolver.js

@@ -0,0 +1,179 @@
+import { constants } from "node:fs";
+import { access, lstat, realpath, stat } from "node:fs/promises";
+import { posix, win32 } from "node:path";
+const UNAVAILABLE_CODE = "project_context_unavailable";
+const WINDOWS_EXTENDED_PREFIX = "\\\\?\\";
+const WINDOWS_EXTENDED_UNC_PREFIX = "\\\\?\\UNC\\";
+const WINDOWS_DEVICE_PREFIX = "\\\\.\\";
+const WINDOWS_DRIVE_ABSOLUTE = /^[A-Za-z]:\\/u;
+export class ProjectContextUnavailableError extends Error {
+    projectId;
+    code = UNAVAILABLE_CODE;
+    constructor(projectId) {
+        super(UNAVAILABLE_CODE);
+        this.projectId = projectId;
+        Object.defineProperty(this, "name", {
+            configurable: true,
+            value: "ProjectContextUnavailableError",
+        });
+    }
+    toJSON() {
+        return { projectId: this.projectId, code: this.code };
+    }
+}
+const compareProjectIds = (left, right) => {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+const warningFor = (projectId) => Object.freeze({
+    projectId,
+    code: UNAVAILABLE_CODE,
+});
+const nodeFilesystem = { lstat, stat, access, realpath };
+/**
+ * Shape/access preflight only. In particular, fs.access cannot prove effective Windows ACL access;
+ * process launch remains authoritative and Windows capability enablement is owned outside this module.
+ */
+const preflightDirectory = async (root, filesystem) => {
+    try {
+        const entry = await filesystem.lstat(root);
+        if (!entry.isDirectory()) {
+            if (!entry.isSymbolicLink())
+                return false;
+            if (!(await filesystem.stat(root)).isDirectory())
+                return false;
+        }
+        await filesystem.access(root, constants.R_OK | constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const registryByProjectId = (registrations) => new Map(registrations.map((registration) => [registration.projectId, registration]));
+const hasUncServerAndShare = (root, prefixLength) => {
+    const [server, share] = root.slice(prefixLength).split("\\");
+    return server !== undefined && server.length > 0 && share !== undefined && share.length > 0;
+};
+const normalizeWindowsRoot = (root) => {
+    const normalized = win32.normalize(root);
+    const lower = normalized.toLowerCase();
+    const extendedPrefix = WINDOWS_EXTENDED_PREFIX.toLowerCase();
+    const extendedUncPrefix = WINDOWS_EXTENDED_UNC_PREFIX.toLowerCase();
+    if (normalized.startsWith(WINDOWS_DEVICE_PREFIX))
+        return null;
+    if (lower.startsWith(extendedUncPrefix)) {
+        return hasUncServerAndShare(normalized, WINDOWS_EXTENDED_UNC_PREFIX.length)
+            ? normalized
+            : null;
+    }
+    if (lower.startsWith(extendedPrefix)) {
+        return WINDOWS_DRIVE_ABSOLUTE.test(normalized.slice(WINDOWS_EXTENDED_PREFIX.length))
+            ? normalized
+            : null;
+    }
+    if (WINDOWS_DRIVE_ABSOLUTE.test(normalized))
+        return win32.resolve(normalized);
+    if (!normalized.startsWith("\\\\"))
+        return null;
+    return hasUncServerAndShare(normalized, 2) ? win32.resolve(normalized) : null;
+};
+const normalizeRegisteredRoot = (root, platform) => {
+    if (root.length === 0)
+        return null;
+    if (platform === "win32")
+        return normalizeWindowsRoot(root);
+    return posix.isAbsolute(root) ? posix.resolve(root) : null;
+};
+const rootIdentity = (root, platform) => {
+    if (platform !== "win32")
+        return root;
+    const lower = root.toLowerCase();
+    if (lower.startsWith(WINDOWS_EXTENDED_UNC_PREFIX.toLowerCase())) {
+        return win32.normalize(`\\\\${root.slice(WINDOWS_EXTENDED_UNC_PREFIX.length)}`).toLowerCase();
+    }
+    if (lower.startsWith(WINDOWS_EXTENDED_PREFIX.toLowerCase())) {
+        return win32.normalize(root.slice(WINDOWS_EXTENDED_PREFIX.length)).toLowerCase();
+    }
+    return root.toLowerCase();
+};
+export async function resolveProjectContext(snapshot, registry, options = {}) {
+    if (snapshot.projectIds.length === 0 && snapshot.primaryProjectId === undefined) {
+        return Object.freeze({
+            secondary: Object.freeze([]),
+            warnings: Object.freeze([]),
+        });
+    }
+    const platform = options.platform ?? process.platform;
+    const filesystem = options.filesystem ?? nodeFilesystem;
+    const sortedProjectIds = [...snapshot.projectIds].sort(compareProjectIds);
+    const primaryProjectId = snapshot.primaryProjectId;
+    let registrations;
+    try {
+        registrations = await registry.list();
+    }
+    catch {
+        registrations = Object.freeze([]);
+    }
+    const localProjects = registryByProjectId(registrations);
+    const seenRoots = new Set();
+    const resolveOne = async (projectId) => {
+        const registration = localProjects.get(projectId);
+        if (registration === undefined)
+            return { status: "unavailable" };
+        const root = normalizeRegisteredRoot(registration.root, platform);
+        if (root === null || !(await preflightDirectory(root, filesystem))) {
+            return { status: "unavailable" };
+        }
+        let physicalRoot;
+        try {
+            physicalRoot = await filesystem.realpath(root);
+        }
+        catch {
+            return { status: "unavailable" };
+        }
+        const normalizedPhysicalRoot = normalizeRegisteredRoot(physicalRoot, platform);
+        if (normalizedPhysicalRoot === null)
+            return { status: "unavailable" };
+        const identity = rootIdentity(normalizedPhysicalRoot, platform);
+        if (seenRoots.has(identity))
+            return { status: "duplicate" };
+        seenRoots.add(identity);
+        return {
+            status: "resolved",
+            project: Object.freeze({ projectId, root }),
+        };
+    };
+    let primary;
+    if (primaryProjectId !== undefined) {
+        if (!sortedProjectIds.includes(primaryProjectId)) {
+            throw new ProjectContextUnavailableError(primaryProjectId);
+        }
+        const resolvedPrimary = await resolveOne(primaryProjectId);
+        if (resolvedPrimary.status !== "resolved") {
+            throw new ProjectContextUnavailableError(primaryProjectId);
+        }
+        primary = resolvedPrimary.project;
+    }
+    const secondary = [];
+    const warnings = [];
+    for (const projectId of sortedProjectIds) {
+        if (projectId === primaryProjectId)
+            continue;
+        const resolved = await resolveOne(projectId);
+        if (resolved.status === "unavailable")
+            warnings.push(warningFor(projectId));
+        else if (resolved.status === "resolved")
+            secondary.push(resolved.project);
+    }
+    const base = {
+        secondary: Object.freeze(secondary),
+        warnings: Object.freeze(warnings),
+    };
+    return primary === undefined
+        ? Object.freeze(base)
+        : Object.freeze({ primary, ...base });
+}

package/dist/project-workspaces/types.js

@@ -0,0 +1 @@
+export {};

package/dist/prompt.js

@@ -20,6 +20,46 @@ const EXTERNAL_RESULT_READABILITY = `
 - 有足够重点时,只加粗三到五处真正决定性的数字、最终状态、风险、截止时间、负责人或行动项;不足三处时宁缺毋滥。加粗范围要短,不要整段加粗,不要把每个数字都加粗,不得强化未经验证的判断。
 - 需要颜色层级时,只在确有对应语义的短加粗重点前使用一个彩色圆点:🟢 绿色圆点表示已验证成功或健康,🟠 橙色圆点表示风险、临期或需要关注,🔴 红色圆点表示失败、阻塞或严重异常,🔵 蓝色圆点表示负责人、行动项或关键中性数据。每个短加粗重点前最多放一个;不要给普通段落、标题或每个要点都加标记。
 - 使用标题、列表、引用、彩色圆点和加粗形成在企微原生流式消息中稳定可见的层级;不得输出 \`<font>\` 或其它 HTML 标色标签。`;
+const compareProjectIds = (left, right) => {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+const JSON_SINGLE_LINE_ESCAPE = /[\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/gu;
+const escapeJsonSingleLineControls = (json) => json.replace(JSON_SINGLE_LINE_ESCAPE, (character) => `\\u${character.codePointAt(0).toString(16).padStart(4, "0")}`);
+const canonicalJsonString = (value) => escapeJsonSingleLineControls(JSON.stringify(value));
+const canonicalJsonRecord = (value) => escapeJsonSingleLineControls(JSON.stringify(value));
+/**
+ * Resolved paths are daemon-local facts. JSON rows keep paths with spaces or Unicode as data,
+ * never as shell fragments; warning rows expose only logical IDs and stable codes, never roots.
+ */
+export function buildRuntimeWorkspacePrompt(projectContext) {
+    if (projectContext?.primary === undefined)
+        return "";
+    const projectRoles = [
+        { role: "primary", ...projectContext.primary },
+        ...[...projectContext.secondary]
+            .sort((left, right) => compareProjectIds(left.projectId, right.projectId))
+            .map((project) => ({ role: "secondary", ...project })),
+    ].map(({ role, projectId, root }) => `- ${canonicalJsonRecord({ role, projectId, root })}`);
+    const projectWarnings = [...projectContext.warnings]
+        .sort((left, right) => compareProjectIds(left.projectId, right.projectId)
+        || compareProjectIds(left.code, right.code))
+        .map(({ projectId, code }) => `- ${canonicalJsonRecord({ projectId, code })}`);
+    const warningsBlock = projectWarnings.length === 0
+        ? ""
+        : `\n\n## Daemon-local project warnings\n${projectWarnings.join("\n")}`;
+    return `\n\n## Runtime workspace boundaries
+Repository cwd: ${canonicalJsonString(projectContext.primary.root)}. Use it for source, builds, tests, and Git operations.
+Task state directory: $CREW_TASK_DIR. Put downloads, diagnostics, drafts, reports, and temporary artifacts there.
+Work log: $CREW_TASK_LOG. Do not treat the repository as NowWork task storage.
+Runtime permission and sandbox rules still govern repository writes; project binding grants no additional write access.
+
+## Daemon-local project roles
+${projectRoles.join("\n")}${warningsBlock}`;
+}
 export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     if (workLog.length <= cap)
         return workLog;

package/dist/runtimes/claude.js

@@ -1,6 +1,8 @@
 /**
  * Claude Code runtime 适配:print + stream-json 模式,headless 驱动。
  */
+import { realpath } from "node:fs/promises";
+import { posix, win32 } from "node:path";
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
 // Claude Code 原生 --effort 档位(claude 2.1.196 实测:--help 与非法值告警均枚举这五档)。
@@ -9,6 +11,237 @@ export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 // 未配置/非法档位时的默认思考强度:medium 开启原生 thinking(终端透传要展示思考过程),
 // 又不至于 high/max 的 token 开销;agent 配置白名单档位可覆盖。
 export const CLAUDE_DEFAULT_EFFORT = "medium";
+export const CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_MIN_VERSION = "2.1.237";
+export const CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV = "CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD";
+const CLAUDE_VERSION_PROBE_TIMEOUT_MS = 1_000;
+const CLAUDE_VERSION_PROBE_KILL_GRACE_MS = 250;
+const CLAUDE_VERSION_PROBE_MAX_BUFFER = 8 * 1024;
+const CLAUDE_VERSION_PROBE_SUCCESS_TTL_MS = 30_000;
+const CLAUDE_REALPATH_TIMEOUT_MS = 250;
+const ignoreTerminalProbeError = () => undefined;
+const defaultVersionProbeSpawner = (file, args, options) => spawn(file, [...args], options);
+const versionProbeCache = new Map();
+const probeClaudeVersionOnce = (bin, env, start, dependencies) => {
+    // A .cmd launch creates an unmanaged cmd.exe process tree. Without a Job Object or another
+    // verifiable owner, a timeout cannot safely distinguish that tree from PID reuse. Fail closed:
+    // directory access remains available, but nested CLAUDE.md auto-loading stays unverified.
+    if ((dependencies.platform ?? process.platform) === "win32")
+        return Promise.resolve(null);
+    let child;
+    try {
+        child = start(bin, ["--version"], {
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            shell: false,
+        });
+    }
+    catch {
+        return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let closed = false;
+        let output = Buffer.alloc(0);
+        let resolveClose;
+        const close = new Promise((closeResolve) => { resolveClose = closeResolve; });
+        const waitForClose = async () => {
+            let deadline;
+            try {
+                await Promise.race([
+                    close,
+                    new Promise((waitResolve) => {
+                        deadline = setTimeout(waitResolve, CLAUDE_VERSION_PROBE_KILL_GRACE_MS);
+                    }),
+                ]);
+            }
+            finally {
+                if (deadline !== undefined)
+                    clearTimeout(deadline);
+            }
+        };
+        const append = (chunk) => {
+            if (output.length >= CLAUDE_VERSION_PROBE_MAX_BUFFER)
+                return;
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+            const remaining = CLAUDE_VERSION_PROBE_MAX_BUFFER - output.length;
+            output = Buffer.concat([output, bytes.subarray(0, remaining)]);
+        };
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        const observeClose = () => {
+            if (closed)
+                return;
+            closed = true;
+            resolveClose();
+        };
+        const cleanup = () => {
+            child.stdout?.off("data", append);
+            child.stderr?.off("data", append);
+            child.off("error", onError);
+            child.off("close", onClose);
+            // ChildProcess can report a late error after its final close deadline. Retain one static sink:
+            // it captures no local state, creates no timer, and remains safe until the child is collected.
+            child.off("error", ignoreTerminalProbeError);
+            child.on("error", ignoreTerminalProbeError);
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+        };
+        const settle = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutTimer);
+            cleanup();
+            resolve(value);
+        };
+        const onError = () => {
+            if (!timedOut)
+                settle(null);
+        };
+        const onClose = (code) => {
+            observeClose();
+            if (timedOut)
+                return;
+            const value = output.toString("utf8").trim();
+            settle(code === 0 && value !== "" ? value : null);
+        };
+        const timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            void (async () => {
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch { /* process already exited */ }
+                await waitForClose();
+                if (!closed) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch { /* process already exited */ }
+                    await waitForClose();
+                }
+                settle(null);
+            })();
+        }, CLAUDE_VERSION_PROBE_TIMEOUT_MS);
+        child.on("error", onError);
+        child.on("close", onClose);
+    });
+};
+/** Bounded local-only probe; errors and output never cross the execution protocol. */
+export function probeClaudeVersion(bin, env, start = defaultVersionProbeSpawner, dependencies = {}) {
+    if (start !== defaultVersionProbeSpawner) {
+        return probeClaudeVersionOnce(bin, env, start, dependencies);
+    }
+    const key = JSON.stringify([dependencies.platform ?? process.platform, bin, env.PATH ?? ""]);
+    const now = Date.now();
+    const cached = versionProbeCache.get(key);
+    if (cached !== undefined && (cached.expiresAt === null || cached.expiresAt > now)) {
+        return cached.promise;
+    }
+    if (cached !== undefined)
+        versionProbeCache.delete(key);
+    const pending = probeClaudeVersionOnce(bin, env, start, dependencies);
+    const inFlight = { promise: pending, expiresAt: null };
+    versionProbeCache.set(key, inFlight);
+    void pending.then((version) => {
+        if (versionProbeCache.get(key) !== inFlight)
+            return;
+        if (version === null) {
+            versionProbeCache.delete(key);
+            return;
+        }
+        versionProbeCache.set(key, {
+            promise: Promise.resolve(version),
+            expiresAt: Date.now() + CLAUDE_VERSION_PROBE_SUCCESS_TTL_MS,
+        });
+    });
+    return pending;
+}
+const canonicalDirectoryIdentity = (directory, platform) => {
+    if (platform !== "win32")
+        return posix.normalize(directory);
+    let normalized = directory.replaceAll("/", "\\");
+    const lower = normalized.toLowerCase();
+    if (lower.startsWith("\\\\?\\unc\\"))
+        normalized = `\\\\${normalized.slice(8)}`;
+    else if (lower.startsWith("\\\\?\\"))
+        normalized = normalized.slice(4);
+    return win32.normalize(normalized).toLowerCase();
+};
+export function orderedUniqueClaudeDirectories(directories, excluded = [], platform = process.platform) {
+    const seen = new Set(excluded.map((directory) => canonicalDirectoryIdentity(directory, platform)));
+    const ordered = [];
+    for (const directory of directories) {
+        const identity = canonicalDirectoryIdentity(directory, platform);
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        ordered.push(directory);
+    }
+    return Object.freeze(ordered);
+}
+const canonicalizeWithinDeadline = async (directory, canonicalize) => {
+    let timeout;
+    try {
+        return await Promise.race([
+            Promise.resolve().then(() => canonicalize(directory)).catch(() => directory),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(directory), CLAUDE_REALPATH_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+    }
+};
+/** Preserve caller order while collapsing physical aliases; inaccessible paths fall back to lexical identity. */
+export async function resolveOrderedUniqueClaudeDirectories(directories, excluded = [], canonicalize = realpath, platform = process.platform) {
+    const identity = async (directory) => {
+        const physical = await canonicalizeWithinDeadline(directory, canonicalize);
+        return canonicalDirectoryIdentity(physical, platform);
+    };
+    const [excludedIdentities, identities] = await Promise.all([
+        Promise.all(excluded.map(identity)),
+        Promise.all(directories.map(identity)),
+    ]);
+    const seen = new Set(excludedIdentities);
+    const ordered = [];
+    for (let index = 0; index < directories.length; index += 1) {
+        const directoryIdentity = identities[index];
+        if (seen.has(directoryIdentity))
+            continue;
+        seen.add(directoryIdentity);
+        ordered.push(directories[index]);
+    }
+    return Object.freeze(ordered);
+}
+const parseVersion = (value) => {
+    const match = /(?:^|[^0-9])(\d+)\.(\d+)\.(\d+)(?:[^0-9]|$)/u.exec(value);
+    if (match === null)
+        return null;
+    const version = match.slice(1, 4).map(Number);
+    return version.every(Number.isSafeInteger)
+        ? [version[0], version[1], version[2]]
+        : null;
+};
+export function isClaudeAdditionalDirectoryInstructionsSupported(versionOutput) {
+    if (versionOutput === null)
+        return false;
+    const version = parseVersion(versionOutput);
+    const minimum = parseVersion(CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_MIN_VERSION);
+    if (version === null || minimum === null)
+        return false;
+    for (let index = 0; index < version.length; index += 1) {
+        if (version[index] > minimum[index])
+            return true;
+        if (version[index] < minimum[index])
+            return false;
+    }
+    return true;
+}
 export function buildClaudeArgs(input) {
     const args = [
         "--print",
@@ -28,10 +261,8 @@ export function buildClaudeArgs(input) {
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }
-    if (input.projectSkillsDirectory)
-        args.push("--add-dir", input.projectSkillsDirectory);
-    if (input.agentRootDirectory)
-        args.push("--add-dir", input.agentRootDirectory);
+    for (const directory of input.additionalDirectories ?? [])
+        args.push("--add-dir", directory);
     if (input.effectivePermission === undefined) {
         if (input.dangerous)
             args.push("--dangerously-skip-permissions");