@optimuslabs/harness-map-staging 1.5.43 → 1.5.44

package/dist/log_config_files/runtime/skill_block.js

@@ -9,8 +9,11 @@
  * and each file's hash, never its content); the vault entry is `chmod 000`, and an empty `chmod 000`
  * folder is left at the original path so that no app (Claude Code re-syncing account skills, a
  * plugin update) can put the skill back. A receipt whose folder is no longer listed is restored.
- * A folder is only ever moved when it is a real directory inside the home folder (never the home
- * folder itself) holding a SKILL.md, so a bad path cannot move anything that is not a skill.
+ * Any folder the inventory reported is quarantined, wherever it is, as long as it is a real
+ * directory holding a SKILL.md and never the home folder or a folder above it, so a bad path cannot
+ * move anything that is not a skill. The hooks run as the user, so a folder the user cannot move
+ * (owned by root) fails and is logged. A listed path that is a symlink quarantines the folder it
+ * points to (`quarantinePath`).
  */
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
@@ -25,6 +28,30 @@ function log(message) {
 function permissionBits(path) {
     return lstatSync(path).mode & 0o7777;
 }
+/**
+ * The folder a listed path quarantines: the path itself, or, for a symlink, the folder it points to.
+ * The skills CLI (`npx skills add`) installs one copy in `~/.agents/skills/<name>` and links each
+ * agent's folder to it (`~/.claude/skills/<name>`), and a link was refused, so a skill the server
+ * knew only by its link stayed usable by every agent. Quarantining the folder behind the link closes
+ * it for every link and every agent reading it. A chain of more than eight links is left as it is,
+ * and refused.
+ */
+function quarantinePath(dir) {
+    let path = resolve(dir);
+    for (let hop = 0; hop < 8; hop++) {
+        const next = linkTarget(path);
+        if (next === null)
+            return path;
+        path = next;
+    }
+    return path;
+}
+/** Where the link at `path` leads, or null when `path` is not a link (missing ones included). */
+function linkTarget(path) {
+    if (!exists(path) || !lstatSync(path).isSymbolicLink())
+        return null;
+    return resolve(dirname(path), readlinkSync(path));
+}
 /** The vault id of an original path: one path, one entry. */
 function entryId(dir) {
     return createHash('sha256').update(resolve(dir)).digest('hex').slice(0, 16);
@@ -111,26 +138,31 @@ function sameFiles(a, b) {
 }
 /** When the folder at `dir` was quarantined, or null when it is not. */
 export function quarantinedAt(dir) {
-    const receipt = readReceipt(entryId(dir));
+    const receipt = readReceipt(entryId(quarantinePath(dir)));
     return receipt && receipt.status !== 'moving' ? receipt.quarantined_at : null;
 }
 /**
  * The receipt of the skill folder quarantined from `dir`, when the empty folder quarantine left
  * is still there. The collection reports such a path as quarantined: its skill cannot have changed
- * since it was moved, and the server keeps the copy it has.
+ * since it was moved, and the server keeps the copy it has. A link to a quarantined folder is
+ * reported the same way.
  */
 export function quarantineReceiptFor(dir) {
-    if (!isStub(resolve(dir)))
+    const path = quarantinePath(dir);
+    if (!isStub(path))
         return null;
-    const receipt = readReceipt(entryId(dir));
+    const receipt = readReceipt(entryId(path));
     return receipt && receipt.status !== 'moving' ? receipt : null;
 }
-/** Why `dir` must not be moved, or null when it is a real skill folder inside the home folder. */
+/**
+ * Why `dir` must not be moved, or null when it is a real skill folder. Any location the inventory
+ * reported can be moved (a project on another drive, a shared folder), except the home folder and
+ * the folders above it.
+ */
 export function refusalReason(dir, home = homedir()) {
-    const root = resolve(home);
     const target = resolve(dir);
-    if (!target.startsWith(root + sep))
-        return 'outside the home folder';
+    if (isHomeOrAbove(target, home))
+        return 'the home folder or above it';
     if (!existsSync(target))
         return 'missing';
     const stat = lstatSync(target);
@@ -138,12 +170,17 @@ export function refusalReason(dir, home = homedir()) {
         return 'symlink';
     if (!stat.isDirectory())
         return 'not a directory';
-    if (!realpathSync(target).startsWith(realpathSync(root) + sep))
-        return 'resolves outside the home folder';
+    if (isHomeOrAbove(realpathSync(target), realpathSync(home)))
+        return 'the home folder or above it';
     if (!existsSync(join(target, 'SKILL.md')))
         return 'no SKILL.md';
     return null;
 }
+/** Whether `dir` is the home folder or a folder that holds it (`/Users`, `/`). */
+function isHomeOrAbove(dir, home) {
+    const folder = dir.endsWith(sep) ? dir : dir + sep;
+    return (resolve(home) + sep).startsWith(folder);
+}
 /** Move a listed folder into the vault, with its receipt, and leave the empty folder behind. */
 function moveIn(dir, id, entry, outcome) {
     const receipt = {
@@ -203,9 +240,9 @@ function keepQuarantined(dir, id, receipt, home, outcome) {
     makeStub(dir);
     outcome.requarantined.push(dir);
 }
-/** Quarantine one listed folder, or keep it quarantined. */
+/** Quarantine one listed folder (the one a link points to), or keep it quarantined. */
 function quarantine(entry, home, outcome) {
-    const dir = resolve(entry.skill_dir);
+    const dir = quarantinePath(entry.skill_dir);
     const id = entryId(dir);
     let receipt = readReceipt(id);
     if (receipt?.status === 'moving') {
@@ -334,7 +371,7 @@ function releaseStateLock(lockPath) {
 }
 function applyUnderLock(entries, home, outcome) {
     releaseInPlaceLocks();
-    const wanted = new Set(entries.map((entry) => entryId(entry.skill_dir)));
+    const wanted = new Set(entries.map((entry) => entryId(quarantinePath(entry.skill_dir))));
     for (const entry of entries) {
         try {
             quarantine(entry, home, outcome);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optimuslabs/harness-map-staging",
-  "version": "1.5.43",
+  "version": "1.5.44",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {