skillvault 0.11.0 → 0.11.2

package/dist/cli.js

@@ -24,7 +24,7 @@ import { resolveScope, resolveRoots, } from './scope.js';
 import { loadCredentials, saveCredentials, loadProjectConfig, saveProjectConfig, } from './credentials.js';
 import { registerProject, unregisterProject, getCurrentProject, listProjects, } from './projects-registry.js';
 import { confirmInstall } from './prompts.js';
-const VERSION = '0.11.0';
+const VERSION = '0.11.2';
 const HOME = process.env.HOME || process.env.USERPROFILE || '~';
 const API_URL = process.env.SKILLVAULT_API_URL || 'https://api.getskillvault.com';
 const CONFIG_DIR = join(HOME, '.skillvault');
@@ -1242,13 +1242,12 @@ function scrubSkillvaultHooks(settingsPath) {
     return removed;
 }
 /**
- * Walk <roots.claudeDir>/skills/ and remove every stub whose manifest.json
- * has an `encrypted: true` flag (the marker we set during install). Returns
- * the list of removed skill names. Vault data is left in place so a future
- * --invite or migrate can reuse it.
+ * Walk a single skills directory and remove every stub whose manifest.json
+ * has an `encrypted: true` flag or a `publisher_id` (the markers we set during
+ * install). Returns the list of removed skill names. Pre-existing skills from
+ * other tools (no manifest, or non-skillvault manifest) are left untouched.
  */
-function removeAllSkillvaultStubs(roots) {
-    const skillsDir = join(roots.claudeDir, 'skills');
+function removeStubsFromDir(skillsDir) {
     if (!existsSync(skillsDir))
         return [];
     const removed = [];
@@ -1268,6 +1267,68 @@ function removeAllSkillvaultStubs(roots) {
     }
     return removed;
 }
+/**
+ * Walk every directory where install would have written a stub and remove
+ * the SkillVault-managed ones. For project mode this is just
+ * <roots.claudeDir>/skills/. For global mode it also covers ~/.agents/skills/
+ * and the agent-agnostic platform mirrors (Cursor, Windsurf, Codex). Vault
+ * data in <roots.vaultDir> is left in place so a future --invite or
+ * migrate-to-project can reuse it.
+ */
+function removeAllSkillvaultStubs(roots) {
+    const all = [];
+    // Always: <roots.claudeDir>/skills/ (the install's primary stub location)
+    all.push(...removeStubsFromDir(join(roots.claudeDir, 'skills')));
+    // Global only: ~/.agents/skills/ + every detected platform mirror.
+    // installSkillStubs writes to all of these in global mode, so the global
+    // uninstall has to clean all of them up too.
+    if (roots.scope === 'global') {
+        all.push(...removeStubsFromDir(AGENTS_SKILLS_DIR));
+        for (const platform of detectAgentPlatforms()) {
+            all.push(...removeStubsFromDir(platform.dir));
+        }
+    }
+    // Dedupe — the same skill_name can appear in multiple mirrors.
+    return [...new Set(all)];
+}
+/**
+ * Remove SkillVault entries from a shared skill-lock.json file, preserving
+ * any entries that belong to other tools (e.g. skill-creator's
+ * sourceType=github wallet skills coexist with our sourceType=skillvault
+ * entries in ~/.agents/.skill-lock.json). If the file ends up with zero
+ * entries, the whole file is deleted.
+ */
+function pruneSkillvaultLockEntries(lockPath) {
+    if (!existsSync(lockPath))
+        return 0;
+    try {
+        const data = JSON.parse(readFileSync(lockPath, 'utf8'));
+        if (!data.skills || typeof data.skills !== 'object')
+            return 0;
+        let removed = 0;
+        for (const [name, entry] of Object.entries(data.skills)) {
+            if (entry && typeof entry === 'object' && (entry.sourceType === 'skillvault' || entry.encrypted === true)) {
+                delete data.skills[name];
+                removed++;
+            }
+        }
+        if (removed === 0)
+            return 0;
+        if (Object.keys(data.skills).length === 0) {
+            try {
+                rmSync(lockPath);
+            }
+            catch { }
+        }
+        else {
+            writeFileSync(lockPath, JSON.stringify(data, null, 2), { mode: 0o600 });
+        }
+        return removed;
+    }
+    catch {
+        return 0;
+    }
+}
 /**
  * Uninstall a single SkillVault install at the given roots.
  *
@@ -1303,8 +1364,17 @@ function uninstallInstall(roots) {
             catch { }
         }
         else {
-            // Global install — preserve credentials.json + projects.json.
-            const PRESERVE = new Set(['credentials.json', 'projects.json']);
+            // Global install — preserve customer identity + publisher CLI state.
+            // credentials.json + projects.json are the customer-side files we
+            // documented as always-preserved. config.json + grants-cache.json are
+            // owned by the publisher CLI (skillvault-publisher) — the customer-
+            // side uninstall has no business deleting publisher login state.
+            const PRESERVE = new Set([
+                'credentials.json',
+                'projects.json',
+                'config.json', // publisher CLI session
+                'grants-cache.json', // publisher CLI grant cache
+            ]);
             for (const entry of readdirSync(roots.configDir)) {
                 if (PRESERVE.has(entry))
                     continue;
@@ -1317,8 +1387,16 @@ function uninstallInstall(roots) {
             }
         }
     }
-    // Skill stubs in <roots.claudeDir>/skills/
+    // Skill stubs in every location install would have written them: always
+    // <roots.claudeDir>/skills/, and (global mode) ~/.agents/skills/ + each
+    // detected platform mirror.
     summary.removedStubs = removeAllSkillvaultStubs(roots);
+    // Prune SkillVault entries from the shared lock file. In global mode this
+    // is ~/.agents/.skill-lock.json which can also hold non-skillvault entries
+    // (e.g. from skill-creator), so we preserve other entries.
+    if (roots.scope === 'global') {
+        pruneSkillvaultLockEntries(AGENTS_LOCK_PATH);
+    }
     // Hooks in settings.json
     summary.removedHooks = scrubSkillvaultHooks(roots.settingsPath);
     // Registry: drop the entry if this was a project install. Use the install

package/dist/credentials.js

@@ -12,10 +12,63 @@
  *   <roots.configDir>/project.json (per install, project- or global-scoped)
  *     Active publishers in this specific install plus install metadata.
  */
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync, existsSync, openSync, closeSync, unlinkSync, } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { credentialsPath } from './scope.js';
+/**
+ * Run `fn` while holding an exclusive advisory lock on `<targetPath>.lock`.
+ * Same primitive as projects-registry.ts withFileLock — duplicated here so
+ * credentials.ts can be locked without crossing module boundaries. See that
+ * file for the design notes (POSIX O_EXCL semantics, busy-wait backoff,
+ * 1s stale-lock reclaim).
+ */
+function withFileLock(targetPath, fn) {
+    const lockPath = targetPath + '.lock';
+    mkdirSync(dirname(lockPath), { recursive: true });
+    const start = Date.now();
+    const TIMEOUT_MS = 1000;
+    let fd = null;
+    while (fd === null) {
+        try {
+            fd = openSync(lockPath, 'wx', 0o600);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'EEXIST')
+                throw err;
+            if (Date.now() - start > TIMEOUT_MS) {
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch { }
+                try {
+                    fd = openSync(lockPath, 'wx', 0o600);
+                }
+                catch {
+                    throw new Error(`Could not acquire lock at ${lockPath} after ${TIMEOUT_MS}ms`);
+                }
+                break;
+            }
+            const buf = new SharedArrayBuffer(4);
+            const view = new Int32Array(buf);
+            Atomics.wait(view, 0, 0, 5 + Math.floor(Math.random() * 10));
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch { }
+        try {
+            unlinkSync(lockPath);
+        }
+        catch { }
+    }
+}
 /**
  * Load customer credentials from ~/.skillvault/credentials.json.
  *
@@ -75,11 +128,20 @@ export function loadCredentials() {
 }
 /**
  * Persist customer credentials to ~/.skillvault/credentials.json with mode 0600.
+ *
+ * Wrapped in withFileLock so two concurrent invites with different invite
+ * codes can't race and silently drop one of each other's publishers from
+ * the publishers[] array. The caller is expected to read-modify-write the
+ * full credentials object themselves; this function only serializes the
+ * write step. For full read-modify-write atomicity, callers should hold
+ * the lock across both load + save (see redeemInvite() in cli.ts).
  */
 export function saveCredentials(creds) {
     const path = credentialsPath();
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 0o600 });
+    withFileLock(path, () => {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 0o600 });
+    });
 }
 function projectConfigPath(roots) {
     return join(roots.configDir, 'project.json');

package/dist/projects-registry.js

@@ -6,10 +6,80 @@
  * `getCurrentProject()` to figure out whether the current CWD already has a
  * registered SkillVault install.
  */
-import { mkdirSync, readFileSync, writeFileSync, existsSync, statSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync, existsSync, statSync, openSync, closeSync, unlinkSync, } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { projectsRegistryPath } from './scope.js';
 const REGISTRY_VERSION = 1;
+/**
+ * Run `fn` while holding an exclusive advisory lock on `<targetPath>.lock`.
+ *
+ * Uses `openSync(..., 'wx')` to atomically create the lockfile (POSIX
+ * O_EXCL semantics — exactly one process succeeds, the rest get EEXIST).
+ * On contention, busy-waits with a small backoff up to ~1s before giving
+ * up. The lockfile is unlinked on completion (success or thrown error)
+ * via try/finally so a crash mid-operation can't permanently wedge
+ * subsequent invocations — though if a process is SIGKILL'd between the
+ * openSync and the closeSync, the lockfile will linger and the next
+ * caller will time out and either inherit the stale lock (forced) or
+ * throw. For our use case (a single-user CLI doing read-modify-write on
+ * a small JSON file), 1s is plenty.
+ *
+ * Used by registerProject + unregisterProject to fix the lost-update race
+ * when two `--invite` commands run concurrently against the same
+ * ~/.skillvault/projects.json (audit scenario 12-concurrent-install).
+ */
+function withFileLock(targetPath, fn) {
+    const lockPath = targetPath + '.lock';
+    mkdirSync(dirname(lockPath), { recursive: true });
+    const start = Date.now();
+    const TIMEOUT_MS = 1000;
+    let fd = null;
+    while (fd === null) {
+        try {
+            fd = openSync(lockPath, 'wx', 0o600);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'EEXIST')
+                throw err;
+            if (Date.now() - start > TIMEOUT_MS) {
+                // Stale lock — assume the previous holder crashed and reclaim it.
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch { }
+                // Loop one more time, but if it still fails, throw.
+                try {
+                    fd = openSync(lockPath, 'wx', 0o600);
+                }
+                catch {
+                    throw new Error(`Could not acquire lock at ${lockPath} after ${TIMEOUT_MS}ms`);
+                }
+                break;
+            }
+            // Busy-wait briefly. The Node.js event loop is single-threaded so
+            // we can't yield to a peer process via Promise without making the
+            // function async — and registerProject is sync. Atomics.wait on a
+            // SharedArrayBuffer is the cleanest sync sleep:
+            const buf = new SharedArrayBuffer(4);
+            const view = new Int32Array(buf);
+            Atomics.wait(view, 0, 0, 5 + Math.floor(Math.random() * 10));
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch { }
+        try {
+            unlinkSync(lockPath);
+        }
+        catch { }
+    }
+}
 function readRegistry() {
     const path = projectsRegistryPath();
     if (!existsSync(path))
@@ -75,29 +145,39 @@ export function listProjects() {
 /**
  * Insert or update a project entry. Matching is by absolute path; if an entry
  * with the same path already exists, it is replaced.
+ *
+ * The read-modify-write is wrapped in withFileLock so two concurrent
+ * `--invite` calls can't race and lose one of each other's updates.
  */
 export function registerProject(entry) {
-    const reg = readRegistry();
-    const normalized = { ...entry, path: resolve(entry.path) };
-    const idx = reg.projects.findIndex((p) => resolve(p.path) === normalized.path);
-    if (idx >= 0) {
-        reg.projects[idx] = normalized;
-    }
-    else {
-        reg.projects.push(normalized);
-    }
-    writeRegistry(reg);
+    withFileLock(projectsRegistryPath(), () => {
+        const reg = readRegistry();
+        const normalized = { ...entry, path: resolve(entry.path) };
+        const idx = reg.projects.findIndex((p) => resolve(p.path) === normalized.path);
+        if (idx >= 0) {
+            reg.projects[idx] = normalized;
+        }
+        else {
+            reg.projects.push(normalized);
+        }
+        writeRegistry(reg);
+    });
 }
 /**
  * Remove the project entry whose path matches. No-op if not present.
+ *
+ * Wrapped in withFileLock for the same reason as registerProject — a
+ * concurrent uninstall + register would otherwise race.
  */
 export function unregisterProject(path) {
-    const reg = readRegistry();
-    const target = resolve(path);
-    const before = reg.projects.length;
-    reg.projects = reg.projects.filter((p) => resolve(p.path) !== target);
-    if (reg.projects.length !== before)
-        writeRegistry(reg);
+    withFileLock(projectsRegistryPath(), () => {
+        const reg = readRegistry();
+        const target = resolve(path);
+        const before = reg.projects.length;
+        reg.projects = reg.projects.filter((p) => resolve(p.path) !== target);
+        if (reg.projects.length !== before)
+            writeRegistry(reg);
+    });
 }
 /**
  * Look up the registry entry that matches the current working directory (or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillvault",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "SkillVault — secure skill distribution for Claude Code",
   "type": "module",
   "bin": {