@nowcrew/daemon 0.6.4 → 0.6.6

package/dist/agent-ability/materializer.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, cp, lstat, mkdir, readFile, readdir, readlink, rename, rm, symlink, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { parse } from "yaml";
 import { dslog } from "../slog.js";
 import { abilitySha256, abilityTreeDigest, collectAbilityFiles, resolveAbilityRelease, safeAbilityName, } from "./resolver.js";
@@ -10,6 +10,8 @@ import { parseSkillFrontmatter } from "../skill-frontmatter.js";
 import { isProjectSkillName, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, } from "../project-skills/types.js";
 import { createAgentProjectionCoordinator, runtimeProjectionLifetime, } from "../project-skills/agent-projection-coordinator.js";
 const exists = (path) => lstat(path).then(() => true, () => false);
+const isRealDirectory = (path) => lstat(path)
+    .then((info) => info.isDirectory() && !info.isSymbolicLink(), () => false);
 const repositoryKey = (url) => createHash("sha256").update(url).digest("hex");
 const posixPath = (value) => value.split(sep).join("/");
 const sameSnapshot = (left, right) => JSON.stringify(left) === JSON.stringify(right);
@@ -208,8 +210,166 @@ const verifyCache = async (agentsRoot, ability) => {
 };
 const layerRelativePath = (path, layer) => path.startsWith(`${layer}/`) ? path.slice(layer.length + 1) : path;
 const readManagedCatalog = async (trainingRoot) => JSON.parse(await readFile(join(trainingRoot, "ACTIVE_RELEASE.json"), "utf8"));
+const trainingSwitchJournalPath = (agentRoot) => join(agentRoot, ".training-switch.json");
+const trainingRollbackRoot = (agentRoot) => join(agentRoot, ".training-rollback");
+const trainingDiscardRoot = (agentRoot) => join(agentRoot, ".training-discard");
+const writeTrainingSwitchJournal = async (agentRoot, journal) => {
+    const target = trainingSwitchJournalPath(agentRoot);
+    const staging = `${target}.next-${randomUUID()}`;
+    await writeFile(staging, JSON.stringify(journal), { encoding: "utf8", mode: 0o600 });
+    await rename(staging, target);
+};
+const readTrainingSwitchJournal = async (agentRoot) => {
+    const raw = await readFile(trainingSwitchJournalPath(agentRoot), "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    });
+    if (raw === null)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("ability_training_switch_journal_invalid");
+    }
+    if (typeof value !== "object" || value === null)
+        throw new Error("ability_training_switch_journal_invalid");
+    const journal = value;
+    if (journal.operation === "install"
+        && (journal.phase === "prepared" || journal.phase === "previous-renamed")
+        && typeof journal.stagingName === "string"
+        && basename(journal.stagingName) === journal.stagingName
+        && journal.stagingName.startsWith(".training-next-")) {
+        return { operation: "install", phase: journal.phase, stagingName: journal.stagingName };
+    }
+    if (journal.operation === "restore"
+        && (journal.phase === "prepared" || journal.phase === "current-moved" || journal.phase === "restored")) {
+        return { operation: "restore", phase: journal.phase };
+    }
+    throw new Error("ability_training_switch_journal_invalid");
+};
+const clearTrainingSwitchJournal = async (agentRoot) => {
+    await rm(trainingSwitchJournalPath(agentRoot), { force: true });
+};
+const assertManagedTrainingTreeIfPresent = async (root, errorCode) => {
+    if (!await exists(root))
+        return false;
+    if (!await isRealDirectory(root))
+        throw new Error(errorCode);
+    const catalog = await readManagedCatalog(root).catch(() => null);
+    if (catalog?.managedBy !== "nowcrew-agent-training")
+        throw new Error(errorCode);
+    return true;
+};
+const finishTrainingRestore = async (agentRoot) => {
+    const trainingRoot = join(agentRoot, "training");
+    const rollbackRoot = trainingRollbackRoot(agentRoot);
+    const discardRoot = trainingDiscardRoot(agentRoot);
+    const hasTraining = await assertManagedTrainingTreeIfPresent(trainingRoot, "ability_workspace_training_conflict");
+    const hasRollback = await assertManagedTrainingTreeIfPresent(rollbackRoot, "ability_training_rollback_invalid");
+    const hasDiscard = await assertManagedTrainingTreeIfPresent(discardRoot, "ability_training_discard_invalid");
+    if (hasTraining && hasRollback && !hasDiscard) {
+        await rename(trainingRoot, discardRoot);
+        await writeTrainingSwitchJournal(agentRoot, { operation: "restore", phase: "current-moved" });
+    }
+    if (!await exists(trainingRoot) && await exists(rollbackRoot)) {
+        await rename(rollbackRoot, trainingRoot);
+        await writeTrainingSwitchJournal(agentRoot, { operation: "restore", phase: "restored" });
+    }
+    if (!await exists(trainingRoot) && !await exists(rollbackRoot) && await exists(discardRoot)) {
+        await rename(discardRoot, trainingRoot);
+    }
+    if (!await exists(trainingRoot))
+        throw new Error("ability_training_restore_incomplete");
+    await removeManagedTree(discardRoot);
+    await clearTrainingSwitchJournal(agentRoot);
+};
+const recoverTrainingSwitch = async (agentRoot) => {
+    const journal = await readTrainingSwitchJournal(agentRoot);
+    if (journal === null)
+        return;
+    const trainingRoot = join(agentRoot, "training");
+    if (journal.operation === "restore") {
+        await finishTrainingRestore(agentRoot);
+        return;
+    }
+    const staging = join(agentRoot, journal.stagingName);
+    const rollbackRoot = trainingRollbackRoot(agentRoot);
+    await assertManagedTrainingTreeIfPresent(trainingRoot, "ability_workspace_training_conflict");
+    await assertManagedTrainingTreeIfPresent(staging, "ability_training_switch_staging_invalid");
+    await assertManagedTrainingTreeIfPresent(rollbackRoot, "ability_training_rollback_invalid");
+    if (await exists(trainingRoot)) {
+        await removeManagedTree(staging);
+    }
+    else if (await exists(staging)) {
+        await rename(staging, trainingRoot);
+    }
+    else if (await exists(rollbackRoot)) {
+        await rename(rollbackRoot, trainingRoot);
+    }
+    else {
+        throw new Error("ability_training_switch_recovery_failed");
+    }
+    await clearTrainingSwitchJournal(agentRoot);
+};
+const switchTrainingDirectory = async (agentRoot, staging) => {
+    await recoverTrainingSwitch(agentRoot);
+    const trainingRoot = join(agentRoot, "training");
+    const rollbackRoot = trainingRollbackRoot(agentRoot);
+    await assertManagedTrainingTreeIfPresent(staging, "ability_training_switch_staging_invalid");
+    await assertManagedTrainingTreeIfPresent(trainingRoot, "ability_workspace_training_conflict");
+    await assertManagedTrainingTreeIfPresent(rollbackRoot, "ability_training_rollback_invalid");
+    await removeManagedTree(rollbackRoot);
+    await writeTrainingSwitchJournal(agentRoot, {
+        operation: "install", phase: "prepared", stagingName: basename(staging),
+    });
+    try {
+        if (await exists(trainingRoot)) {
+            await rename(trainingRoot, rollbackRoot);
+            await writeTrainingSwitchJournal(agentRoot, {
+                operation: "install", phase: "previous-renamed", stagingName: basename(staging),
+            });
+        }
+        await rename(staging, trainingRoot);
+        await clearTrainingSwitchJournal(agentRoot);
+    }
+    catch (error) {
+        await recoverTrainingSwitch(agentRoot).catch(() => { });
+        throw error;
+    }
+};
+const restoreTrainingRollback = async (agentRoot, ability) => {
+    await recoverTrainingSwitch(agentRoot);
+    const currentCatalog = await readManagedCatalog(join(agentRoot, "training")).catch(() => null);
+    const rollbackRoot = trainingRollbackRoot(agentRoot);
+    if (!await isRealDirectory(rollbackRoot))
+        return null;
+    const catalog = await readManagedCatalog(rollbackRoot).catch(() => null);
+    if (catalog?.managedBy !== "nowcrew-agent-training"
+        || catalog.releaseId !== ability.releaseId
+        || catalog.rootCommit !== ability.rootCommit
+        || catalog.artifactDigest !== ability.artifactDigest)
+        return null;
+    const discardRoot = trainingDiscardRoot(agentRoot);
+    await assertManagedTrainingTreeIfPresent(discardRoot, "ability_training_discard_invalid");
+    await removeManagedTree(discardRoot);
+    await writeTrainingSwitchJournal(agentRoot, { operation: "restore", phase: "prepared" });
+    await finishTrainingRestore(agentRoot);
+    dslog("ability.workspace.rollback_restored", "Previous Agent training directory restored locally", {
+        level: "INFO",
+        from_release_id: typeof currentCatalog?.releaseId === "string" ? currentCatalog.releaseId : "unknown",
+        release_id: ability.releaseId,
+        root_commit: ability.rootCommit,
+        artifact_digest: ability.artifactDigest,
+    });
+    return join(agentRoot, "training");
+};
 const activeTrainingRoot = async (agentsRoot, handle, ability) => {
     const trainingRoot = join(agentsRoot, handle, "training");
+    if (!await isRealDirectory(trainingRoot))
+        return null;
     const catalog = await readManagedCatalog(trainingRoot).catch(() => null);
     return catalog?.managedBy === "nowcrew-agent-training"
         && catalog.releaseId === ability.releaseId
@@ -248,6 +408,8 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
     }));
     let previousCatalog = null;
     if (await exists(trainingRoot)) {
+        if (!await isRealDirectory(trainingRoot))
+            throw new Error("ability_workspace_training_conflict");
         previousCatalog = await readManagedCatalog(trainingRoot).catch(() => null);
         if (previousCatalog?.managedBy !== "nowcrew-agent-training") {
             throw new Error("ability_workspace_training_conflict");
@@ -259,7 +421,6 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
     }
     await mkdir(agentRoot, { recursive: true });
     const staging = join(agentRoot, `.training-next-${ability.releaseId}-${randomUUID()}`);
-    const backup = join(agentRoot, `.training-previous-${ability.releaseId}-${randomUUID()}`);
     await mkdir(staging, { recursive: true, mode: 0o700 });
     try {
         const instructionsTarget = join(staging, "instructions", layerRelativePath(ability.instructions.path, "instructions"));
@@ -333,7 +494,7 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
                 await writableTree(join(staging, "workspace", abilityWorkspaceProjectionPath(asset.target)));
             }
         }
-        await switchDirectory(trainingRoot, staging, backup);
+        await switchTrainingDirectory(agentRoot, staging);
     }
     catch (error) {
         await removeManagedTree(staging).catch(() => { });
@@ -341,6 +502,14 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
     }
     return trainingRoot;
 };
+const ensureWorkspaceTraining = async (agentsRoot, handle, ability) => {
+    const agentRoot = join(agentsRoot, handle);
+    await mkdir(agentRoot, { recursive: true });
+    await recoverTrainingSwitch(agentRoot);
+    return await activeTrainingRoot(agentsRoot, handle, ability)
+        ?? await restoreTrainingRollback(agentRoot, ability)
+        ?? await materializeWorkspaceTraining(agentsRoot, handle, ability);
+};
 const projectWorkspaceTraining = async (agentsRoot, handle, ability, trainingRoot) => {
     const agentRoot = join(agentsRoot, handle);
     await projectNativeSkills(agentRoot, trainingRoot, ability.skills);
@@ -355,7 +524,7 @@ export function createAgentAbilityMaterializer(expectedAgentsRoot, coordinator =
     const apply = async (agentsRoot, handle, ability) => {
         if (agentsRoot !== expectedAgentsRoot)
             throw new Error("ability_agents_root_mismatch");
-        const trainingRoot = await materializeWorkspaceTraining(agentsRoot, handle, ability);
+        const trainingRoot = await ensureWorkspaceTraining(agentsRoot, handle, ability);
         await projectWorkspaceTraining(agentsRoot, handle, ability, trainingRoot);
         return { directory: "training", releaseId: ability.releaseId, artifactDigest: ability.artifactDigest };
     };
@@ -388,16 +557,8 @@ export function createAgentAbilityMaterializer(expectedAgentsRoot, coordinator =
             return coordinator.runExclusiveUntil(expectedAgentsRoot, handle, async () => {
                 const started = Date.now();
                 try {
-                    const existingTrainingRoot = await activeTrainingRoot(agentsRoot, handle, ability);
-                    let trainingRoot;
-                    if (existingTrainingRoot !== null) {
-                        trainingRoot = existingTrainingRoot;
-                        await projectWorkspaceTraining(agentsRoot, handle, ability, existingTrainingRoot);
-                    }
-                    else {
-                        await apply(agentsRoot, handle, ability);
-                        trainingRoot = join(agentsRoot, handle, "training");
-                    }
+                    const trainingRoot = await ensureWorkspaceTraining(agentsRoot, handle, ability);
+                    await projectWorkspaceTraining(agentsRoot, handle, ability, trainingRoot);
                     const context = await loadAgentAbilityRuntimeContext(join(agentsRoot, handle), trainingRoot, ability);
                     dslog("ability.execution.materialized", "Agent ability release materialized", {
                         level: "INFO", agent_handle: handle, release_id: ability.releaseId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",