@notis_ai/cli 0.2.0-beta.154.1 → 0.2.0-beta.155.1

package/dist/skill-sync/index.js

@@ -798,12 +798,13 @@ async function downloadSkillBundle(bundleUrl) {
   }
   return Buffer.from(await response.arrayBuffer());
 }
-async function updateAgentTargets(serverUrl, jwt, skillId, targets) {
+async function updateAgentTargets(serverUrl, jwt, skillId, targets, expectedUpdatedAt) {
   return requestJson(`${serverUrl}/portal_skills/agent-targets`, jwt, {
     method: "PATCH",
     body: {
       skill_id: skillId,
-      agent_targets: targets
+      agent_targets: targets,
+      ...expectedUpdatedAt ? { expected_updated_at: expectedUpdatedAt } : {}
     }
   });
 }
@@ -819,6 +820,18 @@ var EXTERNAL_AGENT_SKILL_DIRS = {
   codex: path2.join(HOME_DIR2, ".codex", "skills")
 };
 var EXTERNAL_AGENTS = Object.keys(EXTERNAL_AGENT_SKILL_DIRS);
+var AGENT_FAILURE_LABELS = {
+  claude_code: "Claude Code",
+  cursor: "Cursor",
+  codex: "Codex",
+  legacy: "legacy ~/.agents/skills"
+};
+function agentFailureLabel(agent) {
+  return AGENT_FAILURE_LABELS[agent] ?? agent;
+}
+function agentFolderFailureName(agent) {
+  return `${agentFailureLabel(agent)} skills folder`;
+}
 async function removeForeignAccountSymlinks(skillsDir, options = {}) {
   const agentSkillDirs = { ...defaultAgentSkillDirs(skillsDir), ...options.agentSkillDirs };
   const currentRoot = path2.resolve(skillsDir);
@@ -879,8 +892,9 @@ async function isManagedSymlink(linkPath, managedRoots) {
     const target = await fs2.readlink(linkPath);
     const resolvedTarget = path2.resolve(path2.dirname(linkPath), target);
     return managedRoots.some((root) => resolvedTarget === root || resolvedTarget.startsWith(`${root}${path2.sep}`));
-  } catch {
-    return false;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
   }
 }
 async function ensureCorrectSymlink(linkPath, targetPath) {
@@ -896,7 +910,8 @@ async function ensureCorrectSymlink(linkPath, targetPath) {
     } else {
       return "blocked";
     }
-  } catch {
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
   }
   const relativePath = path2.relative(path2.dirname(linkPath), targetPath);
   await fs2.symlink(relativePath, linkPath);
@@ -908,19 +923,26 @@ function defaultAgentSkillDirs(skillsDir) {
     ...EXTERNAL_AGENT_SKILL_DIRS
   };
 }
-async function removeUndesiredManagedSymlinks(agentDir, desiredSkills, managedRoots) {
+async function removeUndesiredManagedSymlinks(agentDir, desiredSkills, managedRoots, failures, agent) {
   let removed = 0;
   try {
     await fs2.mkdir(agentDir, { recursive: true });
     const existingEntries = await fs2.readdir(agentDir, { withFileTypes: true });
     for (const entry of existingEntries) {
       const entryPath = path2.join(agentDir, entry.name);
-      if (!desiredSkills.has(entry.name) && await isManagedSymlink(entryPath, managedRoots)) {
-        await fs2.unlink(entryPath);
-        removed += 1;
+      try {
+        if (!desiredSkills.has(entry.name) && await isManagedSymlink(entryPath, managedRoots)) {
+          await fs2.unlink(entryPath);
+          removed += 1;
+        }
+      } catch (error) {
+        if (error?.code !== "ENOENT") {
+          failures.push({ name: entry.name, error: `${agentFailureLabel(agent)}: could not remove skill link (${error.message})` });
+        }
       }
     }
-  } catch {
+  } catch (error) {
+    failures.push({ name: agentFolderFailureName(agent), error: `Could not read agent skills directory (${error.message})` });
   }
   return removed;
 }
@@ -965,7 +987,7 @@ async function detectDeletedAgentSymlinks(cloudSkills, previousState, skillsDir
         continue;
       }
       const previous = previousState.skills[skill.name];
-      if (!previous) {
+      if (!previous || previous.cloudId !== skill.id || previous.verifiedAgentLinks?.[agent] !== true || !skill.updated_at || previous.cloudUpdatedAt !== skill.updated_at) {
         continue;
       }
       const cloudTargets = normalizeAgentTargets(skill.agent_targets);
@@ -996,7 +1018,9 @@ async function syncSymlinks(skills, skillsDir = LEGACY_AGENTS_SKILLS_DIR, option
   const result = {
     linked: 0,
     removed: 0,
-    skipped: 0
+    skipped: 0,
+    verifiedAgentLinks: {},
+    failures: []
   };
   const agentSkillDirs = { ...defaultAgentSkillDirs(skillsDir), ...options.agentSkillDirs };
   const legacyGlobalSkillsDir = options.legacyGlobalSkillsDir || LEGACY_AGENTS_SKILLS_DIR;
@@ -1031,21 +1055,34 @@ async function syncSymlinks(skills, skillsDir = LEGACY_AGENTS_SKILLS_DIR, option
       result.skipped += desiredByAgent[agent].size;
       continue;
     }
-    await fs2.mkdir(agentDir, { recursive: true });
+    try {
+      await fs2.mkdir(agentDir, { recursive: true });
+    } catch (error) {
+      result.failures.push({ name: agentFolderFailureName(agent), error: `Could not create agent skills directory (${error.message})` });
+      continue;
+    }
     const desiredSkills = desiredByAgent[agent];
     if (options.removeUndesired !== false) {
-      result.removed += await removeUndesiredManagedSymlinks(agentDir, desiredSkills, managedRoots);
+      result.removed += await removeUndesiredManagedSymlinks(agentDir, desiredSkills, managedRoots, result.failures, agent);
     }
     for (const skillName of desiredSkills) {
       const targetPath = path2.join(skillsDir, skillName);
       const linkPath = path2.join(agentDir, safeName(skillName, agentDir));
       try {
-        await fs2.access(targetPath);
+        if (!(await fs2.stat(path2.join(targetPath, "SKILL.md"))).isFile()) throw new Error("Missing SKILL.md");
       } catch {
         result.skipped += 1;
+        result.failures.push({ name: skillName, error: `${agentFailureLabel(agent)}: SKILL.md is missing or unreadable` });
+        continue;
+      }
+      let syncOutcome;
+      try {
+        syncOutcome = await ensureCorrectSymlink(linkPath, targetPath);
+      } catch (error) {
+        result.skipped += 1;
+        result.failures.push({ name: skillName, error: `${agentFailureLabel(agent)}: could not create skill link (${error.message})` });
         continue;
       }
-      const syncOutcome = await ensureCorrectSymlink(linkPath, targetPath);
       if (syncOutcome === "linked") {
         result.linked += 1;
       } else if (syncOutcome === "blocked") {
@@ -1053,9 +1090,13 @@ async function syncSymlinks(skills, skillsDir = LEGACY_AGENTS_SKILLS_DIR, option
           `[skill-sync] Could not link "${skillName}" for ${agent}: non-symlink entry blocks ${linkPath}`
         );
         result.skipped += 1;
+        result.failures.push({ name: skillName, error: `${agentFailureLabel(agent)}: an existing file or folder blocks the skill link` });
       } else {
         result.skipped += 1;
       }
+      if (syncOutcome !== "blocked") {
+        result.verifiedAgentLinks[skillName] = { ...result.verifiedAgentLinks[skillName], [agent]: true };
+      }
     }
   }
   if (options.removeUndesired !== false && !Object.values(agentSkillDirs).some(
@@ -1064,7 +1105,9 @@ async function syncSymlinks(skills, skillsDir = LEGACY_AGENTS_SKILLS_DIR, option
     result.removed += await removeUndesiredManagedSymlinks(
       legacyGlobalSkillsDir,
       /* @__PURE__ */ new Set(),
-      managedRoots
+      managedRoots,
+      result.failures,
+      "legacy"
     );
   }
   return result;
@@ -1188,7 +1231,7 @@ function shouldWriteCloudSkill(cloudSkill, localSkills, previousState) {
   const localChangedSinceLastSync = !previous || previous.folderHash !== localSkill.folderHash;
   return !localChangedSinceLastSync && Boolean(cloudHash) && cloudHash !== localSkill.folderHash;
 }
-function buildSyncState(pullResponse, localSkills, lastSyncedAt) {
+function buildSyncState(pullResponse, localSkills, lastSyncedAt, verifiedAgentLinks = {}) {
   const localSkillMap = toSkillMap(localSkills);
   const skills = Object.fromEntries(
     pullResponse.skills.map((skill) => {
@@ -1199,6 +1242,8 @@ function buildSyncState(pullResponse, localSkills, lastSyncedAt) {
           cloudId: skill.id,
           folderHash: localSkill?.folderHash || skill.skill_folder_hash || "",
           agentTargets: normalizeAgentTargets(skill.agent_targets),
+          verifiedAgentLinks: skill.status === "active" ? verifiedAgentLinks[skill.name] ?? {} : {},
+          cloudUpdatedAt: skill.updated_at,
           syncedAt: lastSyncedAt || (/* @__PURE__ */ new Date()).toISOString()
         }
       ];
@@ -1254,7 +1299,7 @@ function applyLegacyFirstRunState(localSkills, scopedState, legacyState) {
     skills: migratedSkills
   };
 }
-async function writePulledSkillsToScopedMirror(pullResponse, localSkills, previousState, syncPaths, deps) {
+async function writePulledSkillsToScopedMirror(pullResponse, localSkills, previousState, syncPaths, deps, failures = []) {
   const localSkillMap = toSkillMap(localSkills);
   const warnSkillSync = (message, error) => {
     console.warn(`[Notis] ${message}`, error);
@@ -1270,6 +1315,8 @@ async function writePulledSkillsToScopedMirror(pullResponse, localSkills, previo
       onWarning: warnSkillSync
     })) {
       downloaded += 1;
+    } else {
+      failures.push({ name: cloudSkill.name, error: "Skill content could not be downloaded or written; sync will retry" });
     }
   }
   return downloaded;
@@ -1297,25 +1344,42 @@ async function materializeCloudSkillsForLocalShell(serverUrl, jwt, dependencies
   assertSkillsPullAuthorized(pullResponse);
   const previousState = await deps.readSyncState(syncPaths);
   const localSkills = await deps.scanLocalSkills(syncPaths);
+  const failedDownloads = [];
   const downloaded = await writePulledSkillsToScopedMirror(
     pullResponse,
     localSkills,
     previousState,
     syncPaths,
-    deps
+    deps,
+    failedDownloads
   );
   const finalLocalSkills = await deps.scanLocalSkills(syncPaths);
   const lastSyncedAt = pullResponse.last_synced_at || (/* @__PURE__ */ new Date()).toISOString();
   const relinkSkillNames = new Set(options.relinkSkillNames || []);
+  const failures = [...failedDownloads];
+  const verifiedLinks = {};
+  for (const skill of pullResponse.skills) {
+    const previous = previousState.skills[skill.name];
+    if (skill.updated_at && previous?.cloudId === skill.id && previous.cloudUpdatedAt === skill.updated_at) {
+      verifiedLinks[skill.name] = { ...previous.verifiedAgentLinks };
+    }
+  }
   if (relinkSkillNames.size > 0) {
-    await deps.syncSymlinks(
+    const relinked = await deps.syncSymlinks(
       pullResponse.skills.filter((skill) => relinkSkillNames.has(skill.name)),
       syncPaths.skillsDir,
       { removeUndesired: false }
     );
+    failures.push(...(relinked.failures ?? []).filter(
+      (failure) => !failedDownloads.some((download) => download.name === failure.name)
+    ));
+    for (const name of relinkSkillNames) {
+      verifiedLinks[name] = relinked.verifiedAgentLinks?.[name] ?? {};
+    }
   }
+  for (const failure of failedDownloads) delete verifiedLinks[failure.name];
   await deps.writeSyncState(
-    buildSyncState(pullResponse, finalLocalSkills, lastSyncedAt),
+    buildSyncState(pullResponse, finalLocalSkills, lastSyncedAt, verifiedLinks),
     syncPaths
   );
   return {
@@ -1323,10 +1387,11 @@ async function materializeCloudSkillsForLocalShell(serverUrl, jwt, dependencies
     downloaded,
     deleted: 0,
     removed: 0,
-    lastSyncedAt
+    lastSyncedAt,
+    ...failures.length ? { failedLinks: failures } : {}
   };
 }
-async function deactivateDeletedAgentSkills(serverUrl, jwt, pullResponse, previousState, scopedState, skillsDir, deps) {
+async function deactivateDeletedAgentSkills(serverUrl, jwt, pullResponse, previousState, scopedState, skillsDir, deps, failures) {
   if (isEmptySyncState(scopedState)) {
     return 0;
   }
@@ -1338,22 +1403,6 @@ async function deactivateDeletedAgentSkills(serverUrl, jwt, pullResponse, previo
   if (deletions.length === 0) {
     return 0;
   }
-  const latestSkillsById = new Map(pullResponse.skills.map((skill) => [skill.id, skill]));
-  let fresh = null;
-  try {
-    fresh = await deps.pullSkills(serverUrl, jwt);
-  } catch (error) {
-    console.warn(
-      "[skill-sync] Could not re-pull latest agent targets before deactivation; using the top-of-sync snapshot.",
-      error
-    );
-  }
-  if (fresh) {
-    assertSkillsPullAuthorized(fresh);
-    for (const skill of fresh.skills) {
-      latestSkillsById.set(skill.id, skill);
-    }
-  }
   const agentsBySkill = /* @__PURE__ */ new Map();
   for (const deletion of deletions) {
     const entry = agentsBySkill.get(deletion.skillId) ?? {
@@ -1363,31 +1412,35 @@ async function deactivateDeletedAgentSkills(serverUrl, jwt, pullResponse, previo
     entry.agents.add(deletion.agent);
     agentsBySkill.set(deletion.skillId, entry);
   }
-  const inMemoryById = new Map(pullResponse.skills.map((skill) => [skill.id, skill]));
+  const fresh = withoutBaseSkills(await deps.pullSkills(serverUrl, jwt));
+  assertSkillsPullAuthorized(fresh);
+  Object.assign(pullResponse, fresh);
+  let needsRefresh = false;
   let deactivated = 0;
   for (const [skillId, { skillName, agents }] of agentsBySkill) {
-    const latest = latestSkillsById.get(skillId);
-    if (!latest) {
-      continue;
-    }
-    const nextTargets = { ...normalizeAgentTargets(latest.agent_targets) };
-    for (const agent of agents) {
-      nextTargets[agent] = false;
-    }
+    const skill = pullResponse.skills.find((item) => item.id === skillId);
+    const previous = previousState.skills[skillName];
+    if (!skill?.updated_at || previous?.cloudUpdatedAt !== skill.updated_at) continue;
+    const patch = Object.fromEntries([...agents].map((agent) => [agent, false]));
     try {
-      await deps.updateAgentTargets(serverUrl, jwt, skillId, nextTargets);
-      const inMemory = inMemoryById.get(skillId);
-      if (inMemory) {
-        inMemory.agent_targets = nextTargets;
+      const saved = await deps.updateAgentTargets(serverUrl, jwt, skillId, patch, skill.updated_at);
+      if (saved.success !== true || !saved.updated_at?.trim() || saved.updated_at === skill.updated_at || !["notis", "claude_code", "cursor", "codex"].every((agent) => typeof saved.agent_targets?.[agent] === "boolean") || ![...agents].every((agent) => saved.agent_targets[agent] === false)) {
+        throw new Error("Assignment update did not return a verified saved revision");
       }
+      skill.agent_targets = saved.agent_targets;
+      skill.updated_at = saved.updated_at;
       deactivated += agents.size;
     } catch (error) {
-      console.warn(
-        `[skill-sync] Failed to deactivate "${skillName}" for ${[...agents].join(", ")} after local symlink deletion:`,
-        error
-      );
+      needsRefresh = true;
+      failures.push({ name: skillName, error: "Could not save the local agent removal; refreshed saved assignments" });
+      console.warn(`[skill-sync] Assignment changed or could not be saved for "${skillName}"; refreshing before reconciliation.`, error);
     }
   }
+  if (needsRefresh) {
+    const refreshed = withoutBaseSkills(await deps.pullSkills(serverUrl, jwt));
+    assertSkillsPullAuthorized(refreshed);
+    Object.assign(pullResponse, refreshed);
+  }
   return deactivated;
 }
 async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
@@ -1430,6 +1483,18 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
     pullResponse.skills.filter((skill) => skill.source === "curated").map((skill) => skill.name)
   );
   const protectedSkillNames = /* @__PURE__ */ new Set([...cloudCuratedSkillNames, ...BASE_SKILL_NAMES]);
+  const scopedState = withoutBaseSkillState(await deps.readSyncState(syncPaths));
+  const assignmentFailures = [];
+  const deactivated = syncSettings.agent_targets_conditional_updates === true ? await deactivateDeletedAgentSkills(
+    serverUrl,
+    jwt,
+    pullResponse,
+    scopedState,
+    scopedState,
+    syncPaths.skillsDir,
+    deps,
+    assignmentFailures
+  ) : 0;
   const authUserId = decodeJwtSubject(jwt);
   let previousAuthState = null;
   if (authUserId && authUserId !== syncUserId) {
@@ -1444,22 +1509,12 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
     protectedSkillNames
   });
   const localSkills = (await deps.scanLocalSkills(syncPaths)).filter((skill) => !BASE_SKILL_NAMES.has(skill.name));
-  const scopedState = withoutBaseSkillState(await deps.readSyncState(syncPaths));
   const previousState = withoutBaseSkillState(applyLegacyFirstRunState(
     localSkills,
     scopedState,
     isEmptySyncState(scopedState) ? !previousAuthState || isEmptySyncState(previousAuthState) ? await deps.readLegacySyncState(syncPaths) : previousAuthState : null
   ));
-  const deactivated = await deactivateDeletedAgentSkills(
-    serverUrl,
-    jwt,
-    pullResponse,
-    previousState,
-    scopedState,
-    syncPaths.skillsDir,
-    deps
-  );
-  await deps.syncSymlinks(
+  const gatheredSymlinkResult = await deps.syncSymlinks(
     buildLocalSymlinkCandidates(pullResponse, localSkills, previousState),
     syncPaths.skillsDir
   );
@@ -1490,21 +1545,25 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
       deleted += 1;
     }
   }
+  const failedDownloads = [];
   const downloaded = await writePulledSkillsToScopedMirror(
     pullResponse,
     localSkills,
     previousState,
     syncPaths,
-    deps
+    deps,
+    failedDownloads
   );
   const finalLocalSkills = (await deps.scanLocalSkills(syncPaths)).filter((skill) => !BASE_SKILL_NAMES.has(skill.name));
   const symlinkResult = await deps.syncSymlinks(
     buildLocalSymlinkCandidates(pullResponse, finalLocalSkills, previousState),
     syncPaths.skillsDir
   );
+  const verifiedLinks = { ...symlinkResult.verifiedAgentLinks ?? {} };
+  for (const failure of failedDownloads) delete verifiedLinks[failure.name];
   const lastSyncedAt = pullResponse.last_synced_at || (/* @__PURE__ */ new Date()).toISOString();
   await deps.writeSyncState(
-    buildSyncState(pullResponse, finalLocalSkills, lastSyncedAt),
+    buildSyncState(pullResponse, finalLocalSkills, lastSyncedAt, verifiedLinks),
     syncPaths
   );
   return {
@@ -1514,9 +1573,12 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
     downloaded,
     deleted,
     deactivated,
-    linked: symlinkResult.linked,
-    removed: foreignLinksRemoved + symlinkResult.removed,
+    linked: gatheredSymlinkResult.linked + symlinkResult.linked,
+    removed: foreignLinksRemoved + gatheredSymlinkResult.removed + symlinkResult.removed,
     skipped: symlinkResult.skipped,
+    failedLinks: [...assignmentFailures, ...failedDownloads, ...(symlinkResult.failures ?? []).filter(
+      (failure) => !failedDownloads.some((download) => download.name === failure.name)
+    )],
     lastSyncedAt,
     failedPushes
   };