abelworkflow 1.1.3 → 1.2.1

package/lib/installer/assets.mjs

@@ -2,7 +2,6 @@ import * as fs from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import {
   backupIfNeeded,
-  pathExists,
   pathTargetExists,
   readJsonFileSafe,
   writeText
@@ -17,9 +16,13 @@ const ignoredSkillPathPatterns = [
   /(^|\/)__pycache__(\/|$)/u,
   /(^|\/)node_modules(\/|$)/u,
   /(^|\/)tmp(\/|$)/u,
-  /(^|\/)build(\/|$)/u,
-  /^dev-browser\/profiles(\/|$)/u,
-  /^dev-browser\/tmp(\/|$)/u
+  /(^|\/)build(\/|$)/u
+];
+
+const devBrowserRuntimePathPatterns = [
+  /^dev-browser\/SKILL\.md$/u,
+  /^dev-browser\/package[^/]*\.json$/u,
+  /^dev-browser\/(?:dist|references)(?:\/|$)/u
 ];
 
 function normalizeRelativePath(path) {
@@ -72,7 +75,11 @@ function mapGitignoreTemplate(relativePath) {
 function shouldCopySkillPath(skillsRoot, sourcePath) {
   const relativePath = normalizeRelativePath(relative(skillsRoot, sourcePath));
   if (!relativePath) return true;
-  if (/(^|\/)dist(\/|$)/u.test(relativePath) && !/^dev-browser\/dist(\/|$)/u.test(relativePath)) return false;
+  if (relativePath === "dev-browser") return true;
+  if (relativePath.startsWith("dev-browser/")) {
+    return devBrowserRuntimePathPatterns.some((pattern) => pattern.test(relativePath));
+  }
+  if (/(^|\/)dist(\/|$)/u.test(relativePath)) return false;
   return !ignoredSkillPathPatterns.some((pattern) => pattern.test(relativePath));
 }
 
@@ -84,8 +91,7 @@ async function collectFiles(root, outputPrefix, { filter, mapTargetPath } = {})
       const sourcePath = join(directory, entry.name);
       if (filter && !filter(root, sourcePath)) continue;
       if (entry.isDirectory()) {
-        const nested = await visit(sourcePath);
-        for (const [key, value] of nested) assets.set(key, value);
+        await visit(sourcePath);
         continue;
       }
       if (!entry.isFile() && !entry.isSymbolicLink()) continue;
@@ -100,14 +106,12 @@ async function collectFiles(root, outputPrefix, { filter, mapTargetPath } = {})
       assets.set(targetRelativePath, {
         content: sourceContent,
         hash: hashBytes(sourceContent),
-        sourceHash: hashBytes(sourceContent),
-        mode: sourceStat.mode & 0o777,
-        sourcePath
+        mode: sourceStat.mode & 0o777
       });
     }
-    return assets;
   }
-  return visit(root);
+  await visit(root);
+  return assets;
 }
 
 async function addAssetTree(manifest, root, outputPrefix, options = {}) {
@@ -131,9 +135,7 @@ async function collectManagedAssets(paths) {
   manifest.set("README.md", {
     content: readmeContent,
     hash: hashBytes(readmeContent),
-    sourceHash: hashBytes(readmeContent),
-    mode: (await fs.stat(readmePath)).mode & 0o777,
-    sourcePath: readmePath
+    mode: (await fs.stat(readmePath)).mode & 0o777
   });
 
   const skillsRoot = join(paths.packageRoot, "skills");
@@ -171,23 +173,30 @@ async function readRegularTarget(targetPath) {
     }
     if (!targetStat.isFile()) return { exists: true, regular: false };
     const content = await fs.readFile(targetPath);
-    return { exists: true, regular: true, hash: hashBytes(content) };
+    return {
+      exists: true,
+      regular: true,
+      hash: hashBytes(content),
+      mode: targetStat.mode & 0o777
+    };
   } catch (error) {
     if (error?.code === "ENOENT") return { exists: false, regular: false };
     throw error;
   }
 }
 
-async function applyManifestEntry(paths, relativePath, asset, previousHash, force, report) {
+async function applyManifestEntry(paths, relativePath, asset, previousHash, force, report, beforeMutation) {
   const targetPath = await resolveManagedFilePath(paths, relativePath);
   const current = await readRegularTarget(targetPath);
   if (!current.exists) {
+    await beforeMutation();
     await writeText(targetPath, asset.content, { backupLimit: 3, mode: asset.mode });
     report.created.push(relativePath);
     return asset.hash;
   }
   if (!current.regular) {
     if (force && current.symbolicLink) {
+      await beforeMutation();
       await backupIfNeeded(targetPath);
       await writeText(targetPath, asset.content, { backupLimit: 3, mode: asset.mode });
       report.updated.push(relativePath);
@@ -197,16 +206,13 @@ async function applyManifestEntry(paths, relativePath, asset, previousHash, forc
     return previousHash;
   }
   if (current.hash === asset.hash) {
+    if (process.platform !== "win32" && current.mode !== asset.mode) await beforeMutation();
     const result = await writeText(targetPath, asset.content, { backupLimit: 3, mode: asset.mode });
     report[result.status === "permission-repaired" ? "updated" : "unchanged"].push(relativePath);
     return asset.hash;
   }
-  if (!previousHash && current.hash === asset.sourceHash) {
-    await writeText(targetPath, asset.content, { backupLimit: 3, mode: asset.mode });
-    report.updated.push(relativePath);
-    return asset.hash;
-  }
   if (previousHash && current.hash === previousHash || force) {
+    await beforeMutation();
     await writeText(targetPath, asset.content, { backupLimit: 3, mode: asset.mode });
     report.updated.push(relativePath);
     return asset.hash;
@@ -215,7 +221,7 @@ async function applyManifestEntry(paths, relativePath, asset, previousHash, forc
   return previousHash;
 }
 
-async function removeStaleManagedFile(paths, relativePath, previousHash, force, report) {
+async function removeStaleManagedFile(paths, relativePath, previousHash, force, report, beforeMutation) {
   if (relativePath.endsWith(".skill-lock.json")) return;
   const targetPath = await resolveManagedFilePath(paths, relativePath);
   const current = await readRegularTarget(targetPath);
@@ -224,12 +230,14 @@ async function removeStaleManagedFile(paths, relativePath, previousHash, force,
     recordConflict(report, relativePath);
     return undefined;
   }
-  if (current.regular && current.hash === previousHash) {
+  if (current.hash === previousHash) {
+    await beforeMutation();
     await fs.rm(targetPath, { force: true });
     report.removed.push(relativePath);
     return undefined;
   }
   if (force) {
+    await beforeMutation();
     await backupIfNeeded(targetPath);
     report.removed.push(relativePath);
     return undefined;
@@ -250,14 +258,21 @@ async function readPackageVersion(paths) {
 async function syncManagedFiles({
   paths,
   force = false,
-  pathPrefix = null
+  pathPrefix = null,
+  beforeMutation = async () => {}
 }) {
+  const packageVersion = await readPackageVersion(paths);
   const previousMetadata = await readInstallMetadata(paths);
   const previousManagedFiles = await readManagedFiles(paths, previousMetadata);
   const manifest = await collectManagedAssets(paths);
   const report = createInstallReport();
   const managedFiles = pathPrefix ? { ...previousManagedFiles } : {};
 
+  for (const [relativePath] of manifest) {
+    if (!pathPrefix || relativePath.startsWith(pathPrefix)) {
+      await resolveManagedFilePath(paths, relativePath);
+    }
+  }
   for (const [relativePath, asset] of manifest) {
     if (pathPrefix && !relativePath.startsWith(pathPrefix)) continue;
     const managedHash = await applyManifestEntry(
@@ -266,7 +281,8 @@ async function syncManagedFiles({
       asset,
       previousManagedFiles[relativePath],
       force,
-      report
+      report,
+      beforeMutation
     );
     if (managedHash) managedFiles[relativePath] = managedHash;
     else delete managedFiles[relativePath];
@@ -274,7 +290,14 @@ async function syncManagedFiles({
   for (const [relativePath, previousHash] of Object.entries(previousManagedFiles)) {
     if (pathPrefix && !relativePath.startsWith(pathPrefix)) continue;
     if (!manifest.has(relativePath)) {
-      const managedHash = await removeStaleManagedFile(paths, relativePath, previousHash, force, report);
+      const managedHash = await removeStaleManagedFile(
+        paths,
+        relativePath,
+        previousHash,
+        force,
+        report,
+        beforeMutation
+      );
       if (managedHash) managedFiles[relativePath] = managedHash;
       else delete managedFiles[relativePath];
     }
@@ -282,39 +305,38 @@ async function syncManagedFiles({
 
   return {
     previousMetadata,
-    packageVersion: await readPackageVersion(paths),
+    packageVersion,
     managedFiles,
     report
   };
 }
 
-async function pathsReferToSameEntry(sourcePath, targetPath) {
-  if (resolve(sourcePath) === resolve(targetPath)) return true;
+async function assertManagedContainerDirectory(targetPath) {
   try {
-    return await fs.realpath(sourcePath) === await fs.realpath(targetPath);
-  } catch {
+    const targetStat = await fs.lstat(targetPath);
+    if (targetStat.isSymbolicLink() || !targetStat.isDirectory()) {
+      throw new Error(`Managed container conflict at ${targetPath}`);
+    }
+    return true;
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
     return false;
   }
 }
 
-async function ensureManagedContainerDirectory(targetPath, sourcePath) {
-  if (await pathExists(targetPath)) {
-    const targetStat = await fs.lstat(targetPath);
-    if (targetStat.isSymbolicLink() && await pathsReferToSameEntry(targetPath, sourcePath)) {
-      await fs.unlink(targetPath);
-    } else if (!targetStat.isDirectory()) {
-      throw new Error(`Managed container conflict at ${targetPath}`);
-    }
+async function ensureManagedContainerDirectories(targetPaths, options = {}) {
+  const existing = await Promise.all(targetPaths.map(assertManagedContainerDirectory));
+  for (let index = 0; index < targetPaths.length; index += 1) {
+    const targetPath = targetPaths[index];
+    if (!existing[index]) await options.beforeMutation?.();
+    await fs.mkdir(targetPath, { recursive: true });
+    await assertManagedContainerDirectory(targetPath);
   }
-  await fs.mkdir(targetPath, { recursive: true });
 }
 
 export {
-  collectManagedAssets,
-  ensureManagedContainerDirectory,
-  pathsReferToSameEntry,
+  ensureManagedContainerDirectories,
   readManagedFiles,
   readPackageVersion,
-  shouldCopySkillPath,
   syncManagedFiles
 };

package/lib/installer/install.mjs

@@ -1,7 +1,14 @@
-import { pathExists } from "../config/store.mjs";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
 import { createPaths } from "../paths.mjs";
-import { readManagedFiles, readPackageVersion, syncManagedFiles } from "./assets.mjs";
-import { linkClaude, linkCodex, linkPi } from "./links.mjs";
+import { readPackageVersion, syncManagedFiles } from "./assets.mjs";
+import {
+  linkClaude,
+  linkCodex,
+  linkPi,
+  linkPiExtensions
+} from "./links.mjs";
+import { withDeploymentLock } from "./lock.mjs";
 import {
   buildInstallMetadata,
   createInstallReport,
@@ -29,7 +36,7 @@ function validatedPaths(paths) {
 function reportFromLinkResults(results) {
   const report = createInstallReport();
   for (const result of results) {
-    if (result.status === "linked" || result.status === "copied") report.linked.push(result.targetPath);
+    if (result.status === "linked") report.linked.push(result.targetPath);
     else if (result.status === "unchanged") report.unchanged.push(result.targetPath);
     else if (result.status === "removed") report.removed.push(result.targetPath);
     else if (result.status === "conflict") {
@@ -51,78 +58,228 @@ async function packageVersionFor(paths, previousMetadata) {
   return readPackageVersion(paths);
 }
 
-async function writeInstallState(paths, assetResult, linkedTargets) {
+async function writeInstallState(paths, assetResult, linkedTargets, workflowInstalled, guard) {
   const metadata = buildInstallMetadata({
     previousMetadata: assetResult.previousMetadata,
     packageVersion: assetResult.packageVersion,
+    workflowInstalled,
     managedFiles: assetResult.managedFiles,
     linkedTargets
   });
-  await writeInstallMetadata(paths, metadata);
+  await writeInstallMetadata(paths, metadata, { guard });
 }
 
-async function installWorkflow(options) {
-  const paths = validatedPaths(options.paths);
+function onceAsync(operation) {
+  let result;
+  return () => {
+    result ??= operation();
+    return result;
+  };
+}
+
+async function writeIncompleteInstallState(paths, previousMetadata, guard) {
+  const packageVersion = await packageVersionFor(paths, previousMetadata);
+  await writeInstallMetadata(paths, buildInstallMetadata({
+    previousMetadata,
+    packageVersion,
+    workflowInstalled: false,
+    managedFiles: previousMetadata.managedFiles ?? {},
+    linkedTargets: previousMetadata.linkedTargets ?? {}
+  }), { guard });
+}
+
+function validatedSkillName(skillName) {
+  if (typeof skillName !== "string"
+    || !skillName
+    || skillName === "."
+    || skillName === ".."
+    || skillName.includes("/")
+    || skillName.includes("\\")
+    || skillName.includes("\0")) {
+    throw new TypeError(`Invalid skill name: ${String(skillName)}`);
+  }
+  return skillName;
+}
+
+async function assertRequiredSkill(paths, skillName) {
+  const skillPath = join(paths.packageRoot, "skills", skillName, "SKILL.md");
+  try {
+    if ((await stat(skillPath)).isFile()) return;
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  throw new Error(`Missing required skill: ${skillPath}`);
+}
+
+async function installWorkflowLocked(paths, options, guard) {
+  await guard();
   const previousMetadata = await readInstallMetadata(paths);
+  const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
+  const markIncomplete = onceAsync(() => writeIncompleteInstallState(paths, previousMetadata, guard));
+  const beforeMutation = async () => {
+    await guard();
+    await markIncomplete();
+  };
   let assetResult;
-
-  if (options.relinkOnly) {
-    if (!(await pathExists(paths.agentsDir))) {
-      throw new Error(`${paths.agentsDir} does not exist; remove --link-only or install first`);
-    }
-    assetResult = {
-      previousMetadata,
-      packageVersion: await packageVersionFor(paths, previousMetadata),
-      managedFiles: await readManagedFiles(paths, previousMetadata),
-      report: createInstallReport()
-    };
-  } else {
+  try {
     assetResult = await syncManagedFiles({
       paths,
-      force: options.force ?? false
+      force: options.force ?? false,
+      beforeMutation
     });
+  } catch (error) {
+    await markIncomplete();
+    throw error;
   }
 
-  const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
-  const linkOptions = { force: options.force ?? false };
-  const claudeResults = await linkClaude(paths, previousLinkedTargets, linkOptions);
-  const codexResults = await linkCodex(paths, previousLinkedTargets, linkOptions);
-  const piResults = await linkPi(paths, previousLinkedTargets, linkOptions);
-  const linkResults = [...claudeResults, ...codexResults, ...piResults];
-  await writeInstallState(paths, assetResult, mergeLinkedTargets(previousLinkedTargets, linkResults));
-  return mergeInstallReports(assetResult.report, reportFromLinkResults(linkResults));
+  const linkResults = [];
+  const linkOptions = {
+    force: options.force ?? false,
+    beforeMutation,
+    onResult: (result) => linkResults.push(result)
+  };
+  try {
+    await linkClaude(paths, previousLinkedTargets, linkOptions);
+    await linkCodex(paths, previousLinkedTargets, linkOptions);
+    await linkPi(paths, previousLinkedTargets, linkOptions);
+  } catch (error) {
+    await writeInstallState(
+      paths,
+      assetResult,
+      mergeLinkedTargets(previousLinkedTargets, linkResults),
+      false,
+      guard
+    );
+    throw error;
+  }
+  const report = mergeInstallReports(assetResult.report, reportFromLinkResults(linkResults));
+  await writeInstallState(
+    paths,
+    assetResult,
+    mergeLinkedTargets(previousLinkedTargets, linkResults),
+    report.conflicts.length === 0,
+    guard
+  );
+  return report;
 }
 
-async function installManagedWorkflow(options = {}) {
-  return installWorkflow({ ...options, paths: validatedPaths(options.paths) });
+async function installWorkflow(options) {
+  const paths = validatedPaths(options.paths);
+  return withDeploymentLock(paths, (guard) => installWorkflowLocked(paths, options, guard));
 }
 
-async function ensureSkillPresent(inputPaths, skillName) {
-  const paths = validatedPaths(inputPaths);
+async function ensureSkillPresentLocked(paths, validatedName, guard) {
+  await guard();
   const previousMetadata = await readInstallMetadata(paths);
-  const assetResult = await syncManagedFiles({
+  const markIncomplete = onceAsync(() => writeIncompleteInstallState(paths, previousMetadata, guard));
+  const beforeMutation = async () => {
+    await guard();
+    await markIncomplete();
+  };
+  let assetResult;
+  try {
+    assetResult = await syncManagedFiles({
+      paths,
+      force: false,
+      pathPrefix: `skills/${validatedName}/`,
+      beforeMutation
+    });
+  } catch (error) {
+    await markIncomplete();
+    throw error;
+  }
+  await writeInstallState(
     paths,
-    force: false,
-    pathPrefix: `skills/${skillName}/`
-  });
-  await writeInstallState(paths, assetResult, previousMetadata.linkedTargets ?? {});
+    assetResult,
+    previousMetadata.linkedTargets ?? {},
+    previousMetadata.workflowInstalled === true
+      && previousMetadata.packageVersion === assetResult.packageVersion
+      && assetResult.report.conflicts.length === 0,
+    guard
+  );
   return assetResult.report;
 }
 
-async function ensurePiResourcesLinked(inputPaths) {
+async function ensureSkillPresent(inputPaths, skillName, continuation) {
+  if (continuation !== undefined && typeof continuation !== "function") {
+    throw new TypeError("Expected a skill continuation function");
+  }
   const paths = validatedPaths(inputPaths);
+  const validatedName = validatedSkillName(skillName);
+  await assertRequiredSkill(paths, validatedName);
+  return withDeploymentLock(paths, async (guard) => {
+    const report = await ensureSkillPresentLocked(paths, validatedName, guard);
+    return continuation ? continuation(report, guard) : report;
+  });
+}
+
+async function ensurePiExtensionsPresentLocked(paths, guard) {
+  await guard();
   const previousMetadata = await readInstallMetadata(paths);
-  const assetResult = await syncManagedFiles({ paths, force: false });
   const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
-  const piResults = await linkPi(paths, previousLinkedTargets, { force: false });
-  await writeInstallState(paths, assetResult, mergeLinkedTargets(previousLinkedTargets, piResults));
-  return mergeInstallReports(assetResult.report, reportFromLinkResults(piResults));
+  const markIncomplete = onceAsync(() => writeIncompleteInstallState(paths, previousMetadata, guard));
+  const beforeMutation = async () => {
+    await guard();
+    await markIncomplete();
+  };
+  let assetResult;
+  try {
+    assetResult = await syncManagedFiles({
+      paths,
+      force: false,
+      pathPrefix: "extensions/",
+      beforeMutation
+    });
+  } catch (error) {
+    await markIncomplete();
+    throw error;
+  }
+
+  const linkResults = [];
+  try {
+    await linkPiExtensions(paths, previousLinkedTargets, {
+      force: false,
+      beforeMutation,
+      onResult: (result) => linkResults.push(result)
+    });
+  } catch (error) {
+    await writeInstallState(
+      paths,
+      assetResult,
+      mergeLinkedTargets(previousLinkedTargets, linkResults),
+      false,
+      guard
+    );
+    throw error;
+  }
+
+  const report = mergeInstallReports(assetResult.report, reportFromLinkResults(linkResults));
+  await writeInstallState(
+    paths,
+    assetResult,
+    mergeLinkedTargets(previousLinkedTargets, linkResults),
+    previousMetadata.workflowInstalled === true
+      && previousMetadata.packageVersion === assetResult.packageVersion
+      && report.conflicts.length === 0,
+    guard
+  );
+  return report;
+}
+
+async function ensurePiExtensionsPresent(inputPaths, continuation) {
+  if (continuation !== undefined && typeof continuation !== "function") {
+    throw new TypeError("Expected an Extensions continuation function");
+  }
+  const paths = validatedPaths(inputPaths);
+  return withDeploymentLock(paths, async (guard) => {
+    const report = await ensurePiExtensionsPresentLocked(paths, guard);
+    return continuation ? continuation(report, guard) : report;
+  });
 }
 
 export {
-  ensurePiResourcesLinked,
+  ensurePiExtensionsPresent,
   ensureSkillPresent,
-  installManagedWorkflow,
   installWorkflow,
   packageVersionFor
 };