@dawn0608/dsh-skill-manager 0.1.5 → 0.1.6

package/lib/sync-daemon.js

@@ -7414,7 +7414,7 @@ var require_dist = __commonJS({
 // src/sync-daemon.js
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { chmod, lstat as lstat2, mkdir, readlink, realpath as realpath2, rename, symlink, unlink, writeFile } from "node:fs/promises";
+import { chmod, lstat as lstat2, mkdir, readlink, realpath as realpath2, rename, stat, symlink, unlink, writeFile } from "node:fs/promises";
 import { createServer } from "node:net";
 import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2 } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -8260,13 +8260,13 @@ async function regularFile(path, limit) {
     const before = await lstat(path);
     if (!before.isFile() || before.size > limit) throw new ManagerError("invalid");
     const file = __using(_stack, await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0)), true);
-    const stat = await file.stat();
-    if (!stat.isFile() || stat.dev !== before.dev || stat.ino !== before.ino || stat.size > limit) {
+    const stat2 = await file.stat();
+    if (!stat2.isFile() || stat2.dev !== before.dev || stat2.ino !== before.ino || stat2.size > limit) {
       throw new ManagerError("conflict");
     }
-    const bytes = Buffer.alloc(stat.size + 1);
+    const bytes = Buffer.alloc(stat2.size + 1);
     const { bytesRead } = await file.read(bytes);
-    if (bytesRead !== stat.size) throw new ManagerError("conflict");
+    if (bytesRead !== stat2.size) throw new ManagerError("conflict");
     return bytes.subarray(0, bytesRead);
   } catch (_) {
     var _error = _, _hasError = true;
@@ -8352,6 +8352,11 @@ async function readDocument(path, parse3 = JSON.parse) {
   if (!isRecord(value)) throw new ManagerError("invalid");
   return { path, bytes, value };
 }
+async function readNativeDocument(path, parse3, required = true) {
+  const document = await readDocument(path, parse3);
+  if (required && !document.bytes?.length) throw new ManagerError("unavailable");
+  return document;
+}
 async function writeDocument({ path, bytes }, value) {
   const content = Buffer.from(JSON.stringify(value, null, 2) + "\n");
   if (content.equals(bytes ?? Buffer.alloc(0))) return;
@@ -8429,43 +8434,23 @@ async function writeCodex(binary, codexHome, path, enabled) {
     child.kill();
   }
 }
-function linkIdentity(stat) {
-  return { dev: stat.dev, ino: stat.ino, birthtimeMs: stat.birthtimeMs };
-}
-function sameLink(stat, identity) {
-  return identity && stat.dev === identity.dev && stat.ino === identity.ino && stat.birthtimeMs === identity.birthtimeMs;
-}
-async function reconcileLink(claudeRoot, skill, old) {
+async function reconcileLink(claudeRoot, skill) {
   const link = join2(claudeRoot, skill.name);
   const target = dirname2(skill.path);
   const existing = await lstat2(link).catch(missing);
-  if (existing) {
-    const valid = existing.isSymbolicLink() && await realpath2(link).catch(missing) === target;
-    return {
-      valid,
-      owned: Boolean(valid && old?.linkOwned && sameLink(existing, old.linkIdentity)),
-      ...valid && old?.linkOwned && sameLink(existing, old.linkIdentity) && { identity: old.linkIdentity }
-    };
-  }
+  if (existing) return existing.isSymbolicLink() && await realpath2(link).catch(missing) === target;
   try {
     await symlink(target, link, "dir");
-    return { valid: true, owned: true, identity: linkIdentity(await lstat2(link)) };
+    return true;
   } catch (error) {
-    if (error.code === "EEXIST") return { valid: false, owned: false };
+    if (error.code === "EEXIST") return false;
     throw error;
   }
 }
-async function dropLink(root, entry, skillPath) {
-  if (!entry.linkOwned || !entry.linkIdentity || !isManagedName(entry.name)) return;
-  const link = join2(root, entry.name);
-  const existing = await lstat2(link).catch(missing);
-  if (!existing?.isSymbolicLink() || !sameLink(existing, entry.linkIdentity)) return;
-  if (resolve2(root, await readlink(link)) === dirname2(skillPath)) await unlink(link).catch(missing);
-}
 async function localDocument(workspace) {
   const directory = join2(workspace, ".claude");
-  const stat = await lstat2(directory).catch(missing);
-  if (stat && (!stat.isDirectory() || await realpath2(directory) !== directory)) throw new ManagerError("conflict");
+  const stat2 = await lstat2(directory).catch(missing);
+  if (stat2 && (!stat2.isDirectory() || await realpath2(directory) !== directory)) throw new ManagerError("conflict");
   return readDocument(join2(directory, "settings.local.json"));
 }
 async function projectPaths(cwd) {
@@ -8511,11 +8496,18 @@ async function createCoordinator({ home, agentsHome, claudeHome, codexHome, code
     const stateDocument = await readDocument(statePath);
     const previous = stateDocument.bytes ? await readSyncState(home) : { version: 1, entries: {}, projects: {} };
     if (!previous || !isRecord(previous.projects)) throw new ManagerError("invalid");
+    const sharedRoot = await stat(join2(agentsHome, "skills")).catch(missing);
+    if (!sharedRoot?.isDirectory()) throw new ManagerError("unavailable");
     const skills = await sharedSkills(agentsHome);
     const codexPath = join2(codexHome, "config.toml");
     const claudePath = join2(claudeHome, "settings.json");
-    const native = await codexRules(await readDocument(codexPath, parse));
-    const initialClaude = overrides(await readDocument(claudePath));
+    const hasBaseline = Object.keys(previous.entries).length > 0;
+    const knownNative = previous.nativePresent ?? { codex: hasBaseline, claude: hasBaseline };
+    const codexDocument = await readNativeDocument(codexPath, parse, knownNative.codex);
+    const claudeDocument = await readNativeDocument(claudePath, JSON.parse, knownNative.claude);
+    const native = await codexRules(codexDocument);
+    const initialClaude = overrides(claudeDocument);
+    const nativePresent = { codex: Boolean(codexDocument.bytes?.length), claude: Boolean(claudeDocument.bytes?.length) };
     const projects = [];
     const enrollment = { ...previous.projects };
     if (action.type === "enroll") {
@@ -8538,14 +8530,22 @@ async function createCoordinator({ home, agentsHome, claudeHome, codexHome, code
       throw new ManagerError("conflict");
     }
     const entries = {};
+    for (const [path, old] of Object.entries(previous.entries)) {
+      if (skills.has(path)) continue;
+      entries[path] = { ...old, error: "unavailable" };
+      for (const project of projects) {
+        const baseline = enrollment[project.directory];
+        if (Object.hasOwn(project.previous, old.name)) baseline[old.name] = project.previous[old.name];
+        else delete baseline[old.name];
+      }
+    }
     const cleanup = /* @__PURE__ */ new Map();
     for (const skill of skills.values()) {
       const { name, path } = skill;
       const old = previous.entries[path];
       const codex = readCodex(native, skill);
       const claude = initialClaude[name] ?? null;
-      const link = await reconcileLink(claudeRoot, skill, old).catch(() => ({ valid: false, owned: false }));
-      const linkOk = link.valid;
+      const linkOk = await reconcileLink(claudeRoot, skill).catch(() => false);
       const rawIntents = localIntents(projects, name);
       const local = [];
       let projectCollision = false;
@@ -8573,8 +8573,6 @@ async function createCoordinator({ home, agentsHome, claudeHome, codexHome, code
         enabled: conflict ? old?.enabled ?? enabled : enabled,
         codex: old?.pending && !explicit ? old.codex : codex.enabled,
         claude: old?.pending && !explicit ? old.claude : claude,
-        linkOwned: link.owned,
-        ...link.identity && { linkIdentity: link.identity },
         ...contested && { contested: true },
         ...conflict && { error: "conflict" }
       };
@@ -8588,7 +8586,7 @@ async function createCoordinator({ home, agentsHome, claudeHome, codexHome, code
       }
       entries[path] = entry;
     }
-    const state = { version: 1, entries, projects: enrollment, health: {
+    const state = { version: 1, entries, projects: enrollment, nativePresent, health: {
       ...previous.health,
       status: "syncing",
       lastAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -8601,22 +8599,24 @@ async function createCoordinator({ home, agentsHome, claudeHome, codexHome, code
       try {
         const skill = skills.get(path);
         if (entry.pending) {
-          const current = readCodex(await codexRules(await readDocument(codexPath, parse)), skill);
+          const current = readCodex(await codexRules(await readNativeDocument(codexPath, parse, nativePresent.codex)), skill);
           if (current.enabled !== enabled) {
             if (current.byName || current.enabled !== entry.codex) throw new ManagerError("conflict");
             await writeSkill(codexBinary, codexHome, current.path, enabled);
-            const confirmed = readCodex(await codexRules(await readDocument(codexPath, parse)), skill);
+            const confirmed = readCodex(await codexRules(await readNativeDocument(codexPath, parse)), skill);
             if (confirmed.enabled !== enabled) throw new ManagerError("conflict");
+            nativePresent.codex = true;
           }
           entry.codex = enabled;
           await checkpoint();
-          const settings = await readDocument(claudePath);
+          const settings = await readNativeDocument(claudePath, JSON.parse, nativePresent.claude);
           const currentClaude = overrides(settings)[name] ?? null;
           if (currentClaude !== "off" !== enabled) {
             if (currentClaude !== entry.claude) throw new ManagerError("conflict");
             await writeClaude(settings, name, enabled ? void 0 : "off");
+            nativePresent.claude = true;
           }
-          entry.claude = overrides(await readDocument(claudePath))[name] ?? null;
+          entry.claude = overrides(await readNativeDocument(claudePath, JSON.parse, nativePresent.claude))[name] ?? null;
           if (entry.claude !== "off" !== enabled) throw new ManagerError("conflict");
           await checkpoint();
           delete entry.pending;
@@ -8634,9 +8634,6 @@ async function createCoordinator({ home, agentsHome, claudeHome, codexHome, code
         await checkpoint();
       }
     }
-    for (const [path, old] of Object.entries(previous.entries)) {
-      if (!skills.has(path)) await dropLink(claudeRoot, old, path);
-    }
     state.health.status = Object.values(entries).some((entry) => entry.error) ? "degraded" : "ok";
     if (state.health.status === "ok") state.health.lastSuccessAt = (/* @__PURE__ */ new Date()).toISOString();
     await checkpoint();