@nowcrew/daemon 0.6.77 → 0.6.78

package/dist/project-skills/legacy-cleanup.js

@@ -0,0 +1,224 @@
+/**
+ * 新 daemon 首次启动时清掉旧实现留下的状态:
+ * - <agent>/.crew/project-skill-runtime/(版本化根 + 租约 + 索引):lease 全部终态或超龄则整目录删除;
+ * - 共享目录 .agents/skills 与 .crew/claude-skills/.claude/skills 里的项目 skill 投影(training / ability 链接保留);
+ * - 旧 applied manifest 与切换 journal。
+ * 只在 journal reconcile 之后运行;失败只记日志,不影响能力。
+ */
+import { lstat, readdir, readFile, readlink, rm } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isManagedDirectoryProjectionCopy } from "../directory-projection.js";
+import { sweepExecutionProjections } from "./execution-projection.js";
+export const LEGACY_RUNTIME_STORE = Object.freeze([".crew", "project-skill-runtime"]);
+export const LEGACY_SHARED_SKILL_DIRS = Object.freeze([
+    Object.freeze([".agents", "skills"]),
+    Object.freeze([".crew", "claude-skills", ".claude", "skills"]),
+]);
+const LEGACY_FILES = Object.freeze([
+    Object.freeze([".crew", "project-skills-v2.json"]),
+    Object.freeze([".crew", "project-skills-switch.json"]),
+]);
+const LEGACY_ROOT_MARKER = ".nowcrew-project-skills-root.json";
+const LEGACY_STAGING = /^\.(skills|ability-skills)-(next|previous|discard)-/u;
+const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const isWithin = (root, candidate) => candidate === root || candidate.startsWith(`${root}${sep}`);
+const agentDirectories = async (agentsRoot) => {
+    let entries;
+    try {
+        entries = await readdir(agentsRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+};
+const leaseExecutionIds = async (leasesDir) => {
+    let names;
+    try {
+        names = await readdir(leasesDir);
+    }
+    catch {
+        return [];
+    }
+    const ids = [];
+    for (const name of names) {
+        try {
+            const parsed = JSON.parse(await readFile(join(leasesDir, name), "utf8"));
+            if (typeof parsed.executionId === "string")
+                ids.push(parsed.executionId);
+        }
+        catch { /* 读不出来视为无主 */ }
+    }
+    return ids;
+};
+const newestMtime = async (path) => {
+    let newest = 0;
+    const walk = async (current) => {
+        const info = await lstat(current).catch(() => null);
+        if (info === null)
+            return;
+        newest = Math.max(newest, info.mtimeMs);
+        if (info.isDirectory() && !info.isSymbolicLink()) {
+            for (const entry of await readdir(current).catch(() => []))
+                await walk(join(current, entry));
+        }
+    };
+    await walk(path);
+    return newest;
+};
+const isTerminal = async (journal, executionId) => {
+    const entry = await journal.get(executionId).catch(() => null);
+    return entry === null || entry.state === "completed" || entry.state === "interrupted";
+};
+const ownedByCurrentUser = (uid) => process.getuid === undefined || uid === process.getuid();
+/**
+ * agentRoot 到 directory 的每一层都必须是本用户的真实目录。任一层缺失 / 是 symlink / 不是目录 /
+ * 属于他人 → false(跳过这个目录),绝不抛:清理一个 Agent 失败不该影响其他 Agent,
+ * 更不该让 readdir/rm 顺着换进来的 symlink 删到托管树之外。
+ */
+const isManagedChain = async (agentRoot, directory) => {
+    const rel = relative(agentRoot, directory);
+    if (isAbsolute(rel) || rel.split(sep).includes(".."))
+        return false;
+    const paths = [agentRoot];
+    let current = agentRoot;
+    for (const segment of rel === "" ? [] : rel.split(sep)) {
+        current = join(current, segment);
+        paths.push(current);
+    }
+    for (const path of paths) {
+        const info = await lstat(path).catch(() => null);
+        if (info === null || info.isSymbolicLink() || !info.isDirectory() || !ownedByCurrentUser(info.uid)) {
+            return false;
+        }
+    }
+    return true;
+};
+/** 旧切换实现的 staging/backup/discard 目录是 skills 的兄弟(不是它的子项)。 */
+const removeStagingSiblings = async (parent) => {
+    let entries;
+    try {
+        entries = await readdir(parent, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    let removed = 0;
+    for (const entry of entries) {
+        if (!LEGACY_STAGING.test(entry.name))
+            continue;
+        const path = join(parent, entry.name);
+        const info = await lstat(path).catch(() => null);
+        if (info === null || info.isSymbolicLink() || !info.isDirectory())
+            continue;
+        await rm(path, { recursive: true, force: true });
+        removed += 1;
+    }
+    return removed;
+};
+const cleanSharedDirectory = async (agentRoot, directory, platform) => {
+    const parent = dirname(directory);
+    let removed = (await isManagedChain(agentRoot, parent)) ? await removeStagingSiblings(parent) : 0;
+    if (!await isManagedChain(agentRoot, directory))
+        return removed;
+    const keepRoots = [join(agentRoot, "training", "skills"), join(agentRoot, ".nowcrew", "ability", "releases")];
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return removed;
+    }
+    for (const entry of entries) {
+        const path = join(directory, entry.name);
+        if (entry.name === LEGACY_ROOT_MARKER || LEGACY_STAGING.test(entry.name)) {
+            await rm(path, { recursive: true, force: true });
+            removed += 1;
+            continue;
+        }
+        if (entry.isSymbolicLink()) {
+            const target = resolve(dirname(path), await readlink(path).catch(() => ""));
+            if (keepRoots.some((root) => isWithin(root, target)))
+                continue;
+            await rm(path, { force: true });
+            removed += 1;
+            continue;
+        }
+        if (entry.isDirectory() && platform === "win32" && await isManagedDirectoryProjectionCopy(path, platform)) {
+            await rm(path, { recursive: true, force: true });
+            removed += 1;
+        }
+    }
+    return removed;
+};
+export async function cleanupLegacyProjectSkillState(input) {
+    const platform = input.platform ?? process.platform;
+    const now = input.now ?? Date.now;
+    const maxAgeMs = input.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+    const removedStores = [];
+    const keptStores = [];
+    const failedAgents = [];
+    let removedSharedEntries = 0;
+    for (const handle of await agentDirectories(input.agentsRoot)) {
+        const agentRoot = join(input.agentsRoot, handle);
+        try {
+            const store = join(agentRoot, ...LEGACY_RUNTIME_STORE);
+            // 托管链先行:`.crew` 被换成 symlink 时 store 会落到托管树之外,那里的空 leases 目录会让
+            // `[].every` 判定为"全终态",于是 rm -rf 删到别人的目录里去。链不成立 → 整个 store 块跳过。
+            const storeInfo = (await isManagedChain(agentRoot, dirname(store)))
+                ? await lstat(store).catch(() => null)
+                : null;
+            if (storeInfo?.isDirectory() === true && !storeInfo.isSymbolicLink()) {
+                const ids = await leaseExecutionIds(join(store, "leases"));
+                const terminal = (await Promise.all(ids.map((id) => isTerminal(input.journal, id)))).every(Boolean);
+                // 全终态就不必再走整棵树 stat 了(newestMtime 是深度遍历)。
+                if (terminal || now() - await newestMtime(store) > maxAgeMs) {
+                    await rm(store, { recursive: true, force: true });
+                    removedStores.push(handle);
+                }
+                else {
+                    keptStores.push(handle);
+                }
+            }
+            for (const parts of LEGACY_SHARED_SKILL_DIRS) {
+                removedSharedEntries += await cleanSharedDirectory(agentRoot, join(agentRoot, ...parts), platform);
+            }
+            for (const parts of LEGACY_FILES) {
+                const path = join(agentRoot, ...parts);
+                if (!await isManagedChain(agentRoot, dirname(path)))
+                    continue;
+                if ((await lstat(path).catch(() => null)) !== null) {
+                    await rm(path, { force: true });
+                    removedSharedEntries += 1;
+                }
+            }
+        }
+        catch {
+            // 一个 Agent 的旧状态清不掉,只记一笔继续清下一个 —— 否则第一个坏目录会让每次开机都清不干净。
+            failedAgents.push(handle);
+        }
+    }
+    return Object.freeze({
+        removedStores: Object.freeze(removedStores),
+        keptStores: Object.freeze(keptStores),
+        removedSharedEntries,
+        failedAgents: Object.freeze(failedAgents),
+    });
+}
+export async function sweepAllExecutionProjections(agentsRoot, isLive) {
+    let removed = 0;
+    let kept = 0;
+    let failed = 0;
+    for (const handle of await agentDirectories(agentsRoot)) {
+        try {
+            const result = await sweepExecutionProjections(join(agentsRoot, handle), isLive);
+            removed += result.removed.length;
+            kept += result.kept.length;
+        }
+        catch {
+            // 例如 unmanaged_path:这个 Agent 的投影父目录被换成了 symlink。跳过它,别拖累其他 Agent。
+            failed += 1;
+        }
+    }
+    return Object.freeze({ removed, kept, failed });
+}

package/dist/project-skills/machine-hello-publisher.js

@@ -0,0 +1,20 @@
+import { WebSocket } from "ws";
+/** 记住最近一次 hello 与 socket,便于存储身份变化后重发;Project Skills 状态恒为 ready。 */
+export function createMachineHelloPublisher(input) {
+    let latest = null;
+    let latestSocket = null;
+    const republish = () => {
+        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+            return;
+        const hello = input.effective({ ...latest, projectSkillsStatus: "ready" });
+        try {
+            latestSocket.send(JSON.stringify(hello));
+            input.onSent(hello);
+        }
+        catch { /* 非 OPEN,忽略 */ }
+    };
+    return Object.freeze({
+        publish: (hello, socket) => { latest = hello; latestSocket = socket; republish(); },
+        republish,
+    });
+}