@astrosheep/keiyaku 2.8.2 → 2.8.3

package/build/cli/skills-install.js

@@ -4,10 +4,12 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { FlowError, asMessage } from "../flow-error.js";
+import { VERSION } from "../generated/version.js";
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, "../..");
 const OFFICIAL_SKILLS = ["keiyaku", "keiyaku-akuma"];
 const SKILL_ROOT = path.join(PACKAGE_ROOT, "skills");
+const INSTALL_MARKER = ".keiyaku-skill-owned.json";
 function skillSource(skill) {
     return path.join(SKILL_ROOT, skill);
 }
@@ -50,6 +52,76 @@ function objectKind(stat) {
         return "directory";
     return "other";
 }
+function updateHashField(hash, value) {
+    const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+    const length = Buffer.allocUnsafe(4);
+    length.writeUInt32BE(bytes.length);
+    hash.update(length);
+    hash.update(bytes);
+}
+async function contentHash(root) {
+    const hash = crypto.createHash("sha256");
+    const walk = async (directory, relativeDirectory) => {
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => Buffer.compare(Buffer.from(left.name, "utf8"), Buffer.from(right.name, "utf8")));
+        for (const entry of entries) {
+            const relative = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
+            if (relative === INSTALL_MARKER)
+                continue;
+            const absolute = path.join(directory, entry.name);
+            const stat = await fs.lstat(absolute);
+            const kind = stat.isDirectory() ? "directory"
+                : stat.isFile() ? "file"
+                    : stat.isSymbolicLink() ? "symlink"
+                        : "other";
+            updateHashField(hash, kind);
+            updateHashField(hash, relative);
+            if (kind === "file")
+                updateHashField(hash, await fs.readFile(absolute));
+            if (kind === "symlink")
+                updateHashField(hash, await fs.readlink(absolute));
+            if (kind === "other")
+                updateHashField(hash, `${stat.mode}:${stat.rdev}`);
+            if (kind === "directory")
+                await walk(absolute, relative);
+        }
+    };
+    await walk(root, "");
+    return hash.digest("hex");
+}
+function validMarker(value, skill) {
+    if (!value || typeof value !== "object")
+        return false;
+    const marker = value;
+    return marker.kind === "official-skill-copy"
+        && marker.skill === skill
+        && typeof marker.sourceVersion === "string"
+        && typeof marker.contentHash === "string"
+        && /^[0-9a-f]{64}$/.test(marker.contentHash);
+}
+async function readInstallMarker(target, skill) {
+    try {
+        const markerPath = path.join(target, INSTALL_MARKER);
+        if (!(await fs.lstat(markerPath)).isFile())
+            return undefined;
+        const marker = JSON.parse(await fs.readFile(markerPath, "utf8"));
+        return validMarker(marker, skill) ? marker : undefined;
+    }
+    catch (error) {
+        if (isMissing(error) || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+async function writeInstallMarker(target, skill, hash) {
+    const marker = {
+        kind: "official-skill-copy",
+        skill,
+        sourceVersion: VERSION,
+        contentHash: hash,
+    };
+    await fs.writeFile(path.join(target, INSTALL_MARKER), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+}
 async function classifyTarget(skill, target, canonicalSource) {
     let stat;
     try {
@@ -61,21 +133,39 @@ async function classifyTarget(skill, target, canonicalSource) {
         throw error;
     }
     const kind = objectKind(stat);
-    if (!stat.isSymbolicLink()) {
-        return { skill, path: target, source: canonicalSource, kind: "foreign", foreignIdentity: { kind, dev: stat.dev, ino: stat.ino } };
-    }
-    const originalLink = await fs.readlink(target);
-    try {
-        const resolved = await fs.realpath(path.resolve(path.dirname(target), originalLink));
-        return resolved === canonicalSource
-            ? { skill, path: target, source: canonicalSource, kind: "owned", originalLink }
-            : { skill, path: target, source: canonicalSource, kind: "foreign", originalLink, foreignIdentity: { kind, dev: stat.dev, ino: stat.ino, link: originalLink } };
-    }
-    catch (error) {
-        if (isMissing(error))
-            return { skill, path: target, source: canonicalSource, kind: "foreign", originalLink, foreignIdentity: { kind, dev: stat.dev, ino: stat.ino, link: originalLink } };
-        throw error;
+    if (stat.isDirectory()) {
+        const marker = await readInstallMarker(target, skill);
+        if (marker) {
+            const installedHash = await contentHash(target);
+            if (installedHash === marker.contentHash) {
+                const sourceHash = await contentHash(canonicalSource);
+                return {
+                    skill,
+                    path: target,
+                    source: canonicalSource,
+                    kind: "owned",
+                    needsUpgrade: marker.sourceVersion !== VERSION || marker.contentHash !== sourceHash,
+                };
+            }
+            return {
+                skill,
+                path: target,
+                source: canonicalSource,
+                kind: "foreign",
+                collisionReason: "modified",
+                foreignIdentity: { kind, dev: stat.dev, ino: stat.ino },
+            };
+        }
     }
+    const link = stat.isSymbolicLink() ? await fs.readlink(target) : undefined;
+    return {
+        skill,
+        path: target,
+        source: canonicalSource,
+        kind: "foreign",
+        collisionReason: "foreign",
+        foreignIdentity: { kind, dev: stat.dev, ino: stat.ino, link },
+    };
 }
 async function ensureParent(parent, createdDirectories) {
     const absentBeforeMutation = [];
@@ -159,9 +249,8 @@ async function rollbackAndVerify(originalError, states, createdDirectories) {
         }
         else if (state.kind === "owned") {
             try {
-                const link = await fs.readlink(state.path);
-                const resolved = await fs.realpath(path.resolve(path.dirname(state.path), link));
-                if (link !== state.originalLink || resolved !== state.source) {
+                const marker = await readInstallMarker(state.path, state.skill);
+                if (!marker || await contentHash(state.path) !== marker.contentHash) {
                     failures.push(`owned target changed at ${state.path}`);
                 }
             }
@@ -210,17 +299,21 @@ export async function installOfficialSkills(force = false) {
     }
     const collisions = states.filter((state) => state.kind === "foreign");
     if (collisions.length > 0 && !force) {
-        throw new FlowError("EMPTY_PARAM", `Foreign skill target already exists at ${collisions.map((state) => state.path).join(", ")}. Re-run with -f or --force to replace it.`);
+        const details = collisions.map((state) => state.collisionReason === "modified"
+            ? `${state.path} (owned fact exists but copied content was modified)`
+            : `${state.path} (foreign target or missing ownership fact)`);
+        throw new FlowError("EMPTY_PARAM", `Skill target collision at ${details.join(", ")}. Re-run with -f or --force to replace it.`);
     }
     const createdDirectories = [];
     try {
         for (const state of states) {
-            if (state.kind === "owned")
+            if (state.kind === "owned" && !state.needsUpgrade)
                 continue;
             await ensureParent(path.dirname(state.path), createdDirectories);
             state.temp = siblingArtifact(state.path, "tmp");
-            await fs.symlink(state.source, state.temp, "dir");
-            if (state.kind === "foreign") {
+            await fs.cp(state.source, state.temp, { recursive: true, errorOnExist: true, force: false });
+            await writeInstallMarker(state.temp, state.skill, await contentHash(state.temp));
+            if (state.kind === "foreign" || state.kind === "owned") {
                 state.backup = siblingArtifact(state.path, "backup");
                 await fs.rename(state.path, state.backup);
             }
@@ -248,7 +341,7 @@ export async function installOfficialSkills(force = false) {
             skill: state.skill,
             path: state.path,
             source: state.source,
-            status: state.kind === "owned" ? "owned" : "installed",
+            status: state.installed ? "installed" : "owned",
         })),
         warnings,
     };

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "2.8.2";
+export const VERSION = "2.8.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "2.8.2",
+  "version": "2.8.3",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",