skillvault 0.9.2 → 0.11.0

package/dist/credentials.js

@@ -0,0 +1,108 @@
+/**
+ * Customer credentials and per-install project config storage for the
+ * customer-facing agent CLI.
+ *
+ * Two files, two concerns:
+ *
+ *   ~/.skillvault/credentials.json (always global)
+ *     Customer identity — JWT, email, every publisher this customer can
+ *     access. Never project-scoped, even when the install lives in a
+ *     project directory.
+ *
+ *   <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 { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { credentialsPath } from './scope.js';
+/**
+ * Load customer credentials from ~/.skillvault/credentials.json.
+ *
+ * Falls back to a one-time migration from the legacy
+ * ~/.skillvault/agent-config.json file (the v0.9.x storage layout).
+ * On a successful migration the new credentials.json file is written
+ * but the legacy file is left in place so a downgrade still works.
+ *
+ * Returns null if neither file exists.
+ */
+export function loadCredentials() {
+    const path = credentialsPath();
+    try {
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+    }
+    catch {
+        // fall through to legacy reader
+    }
+    // Legacy fallback: read the old agent-config.json shape and convert.
+    const legacyPath = join(homedir(), '.skillvault', 'agent-config.json');
+    if (!existsSync(legacyPath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(legacyPath, 'utf8'));
+        let publishers;
+        if (raw.token && !raw.publishers) {
+            // Pre-multi-publisher schema: a single token + publisher_id pair.
+            publishers = [{
+                    id: raw.publisher_id,
+                    name: raw.publisher_id,
+                    token: raw.token,
+                    added_at: raw.setup_at || new Date().toISOString(),
+                }];
+        }
+        else {
+            publishers = (raw.publishers || []);
+        }
+        const migrated = {
+            customer_token: raw.customer_token || raw.token || null,
+            customer_email: raw.customer_email || raw.email || null,
+            publishers,
+            api_url: raw.api_url || 'https://api.getskillvault.com',
+            created_at: raw.setup_at || new Date().toISOString(),
+        };
+        // Persist in the new format so the next call hits the fast path.
+        try {
+            saveCredentials(migrated);
+        }
+        catch { }
+        return migrated;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Persist customer credentials to ~/.skillvault/credentials.json with mode 0600.
+ */
+export function saveCredentials(creds) {
+    const path = credentialsPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+function projectConfigPath(roots) {
+    return join(roots.configDir, 'project.json');
+}
+/**
+ * Load this install's project config from <roots.configDir>/project.json.
+ * Returns null if no config exists yet.
+ */
+export function loadProjectConfig(roots) {
+    const path = projectConfigPath(roots);
+    try {
+        if (!existsSync(path))
+            return null;
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Persist project config to <roots.configDir>/project.json with mode 0600.
+ */
+export function saveProjectConfig(roots, config) {
+    mkdirSync(roots.configDir, { recursive: true });
+    writeFileSync(projectConfigPath(roots), JSON.stringify(config, null, 2), { mode: 0o600 });
+}

package/dist/projects-registry.js

@@ -0,0 +1,111 @@
+/**
+ * Projects registry — tracks every known project install path.
+ *
+ * Lives at ~/.skillvault/projects.json (always global, regardless of install
+ * scope). Used by `--all` operations like `uninstall --all` and by
+ * `getCurrentProject()` to figure out whether the current CWD already has a
+ * registered SkillVault install.
+ */
+import { mkdirSync, readFileSync, writeFileSync, existsSync, statSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { projectsRegistryPath } from './scope.js';
+const REGISTRY_VERSION = 1;
+function readRegistry() {
+    const path = projectsRegistryPath();
+    if (!existsSync(path))
+        return { version: REGISTRY_VERSION, projects: [] };
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (Array.isArray(raw)) {
+            // Pre-versioned format: a bare array of entries.
+            return { version: REGISTRY_VERSION, projects: raw };
+        }
+        if (raw && typeof raw === 'object' && Array.isArray(raw.projects)) {
+            return raw;
+        }
+    }
+    catch { }
+    return { version: REGISTRY_VERSION, projects: [] };
+}
+function writeRegistry(reg) {
+    const path = projectsRegistryPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(reg, null, 2), { mode: 0o600 });
+}
+/**
+ * Return all registered project installs. Stale entries (paths that no longer
+ * exist on disk OR exist but are missing the .skillvault directory) are
+ * filtered out and the registry is rewritten on the way out so the next call
+ * is faster.
+ *
+ * Returns an empty array if the registry file does not exist or is malformed.
+ */
+export function listProjects() {
+    const reg = readRegistry();
+    const live = [];
+    let pruned = false;
+    for (const entry of reg.projects) {
+        const path = resolve(entry.path);
+        let stillThere = false;
+        try {
+            const st = statSync(path);
+            if (st.isDirectory()) {
+                // The .skillvault subdir is the install marker. If a customer rm -rf'd
+                // their project but kept the parent path, we shouldn't keep this in
+                // the registry either.
+                stillThere = existsSync(`${path}/.skillvault`);
+            }
+        }
+        catch { }
+        if (stillThere) {
+            live.push(entry);
+        }
+        else {
+            pruned = true;
+        }
+    }
+    if (pruned) {
+        try {
+            writeRegistry({ ...reg, projects: live });
+        }
+        catch { }
+    }
+    return live;
+}
+/**
+ * Insert or update a project entry. Matching is by absolute path; if an entry
+ * with the same path already exists, it is replaced.
+ */
+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);
+}
+/**
+ * Remove the project entry whose path matches. No-op if not present.
+ */
+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);
+}
+/**
+ * Look up the registry entry that matches the current working directory (or
+ * the provided cwd). Returns null if there is no install registered for that
+ * directory.
+ */
+export function getCurrentProject(cwd) {
+    const target = resolve(cwd ?? process.cwd());
+    const reg = readRegistry();
+    return reg.projects.find((p) => resolve(p.path) === target) ?? null;
+}

package/dist/prompts.js

@@ -0,0 +1,193 @@
+/**
+ * Interactive TTY prompts for the customer-facing CLI.
+ *
+ * Two prompts live here:
+ *
+ *   confirmInstall(scope, roots)  → Y/n/g — show install plan, get confirmation
+ *   selectPublishers(available)   → string[] — checkbox list for multi-publisher
+ *
+ * Both use raw stdin + ANSI escape codes (no extra dependencies). When stdin
+ * is not a TTY (CI, scripts, audit harness), they short-circuit:
+ *   - confirmInstall returns 'yes'
+ *   - selectPublishers returns every available publisher (caller can override
+ *     with --publisher / --all flags before calling)
+ */
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * Render the install plan for the resolved scope and ask the customer to
+ * confirm. Returns:
+ *   'yes'    — Y or Enter (default)
+ *   'no'     — n, cancels without writing anything
+ *   'global' — g, switches to global scope
+ *
+ * In non-TTY mode (CI, scripts, audit harness), returns 'yes' immediately
+ * without rendering the prompt.
+ */
+export async function confirmInstall(scope, roots, cwd = process.cwd()) {
+    const lines = renderInstallPlan(scope, roots, cwd);
+    for (const line of lines)
+        console.error(line);
+    if (!process.stdin.isTTY) {
+        console.error('   (non-TTY: auto-confirming)');
+        return 'yes';
+    }
+    process.stderr.write('Continue? [Y/n/g] (Y=yes, n=cancel, g=install globally instead): ');
+    const key = await readSingleKey();
+    console.error('');
+    if (key === 'n' || key === 'N')
+        return 'no';
+    if (key === 'g' || key === 'G')
+        return 'global';
+    // Y, Enter, or anything else → yes (the safe default)
+    return 'yes';
+}
+/**
+ * Build the human-readable preview lines for the install plan. Returned as
+ * an array so callers can also render via dry-run output if they want.
+ */
+export function renderInstallPlan(scope, roots, cwd) {
+    const lines = [];
+    lines.push('');
+    lines.push('🔐 SkillVault Setup');
+    lines.push('');
+    lines.push(`Installing for: ${scope === 'project' ? 'PROJECT (this directory)' : 'GLOBAL (~/.claude, ~/.skillvault)'}`);
+    lines.push(`Location:       ${scope === 'project' ? cwd : homedir()}`);
+    lines.push('');
+    lines.push('Will write:');
+    if (scope === 'project') {
+        lines.push(`  ./.claude/settings.json              (Claude Code hooks)`);
+        lines.push(`  ./.claude/skills/<skill>/            (skill stubs)`);
+        lines.push(`  ./.skillvault/project.json           (project config)`);
+        lines.push(`  ./.skillvault/vaults/                (encrypted skill cache)`);
+    }
+    else {
+        lines.push(`  ~/.claude/settings.json              (Claude Code hooks)`);
+        lines.push(`  ~/.claude/skills/<skill>/            (skill stubs)`);
+        lines.push(`  ~/.skillvault/project.json           (install metadata)`);
+        lines.push(`  ~/.skillvault/vaults/                (encrypted skill cache)`);
+        lines.push(`  ~/.agents/skills/<skill>/            (agent-agnostic mirror)`);
+    }
+    lines.push('');
+    lines.push('Plus user-level (always global):');
+    lines.push(`  ~/.skillvault/credentials.json       (your customer identity)`);
+    lines.push(`  ~/.skillvault/projects.json          (project install registry)`);
+    lines.push('');
+    // Helps callers debug — paths from the resolved roots, in case the spec
+    // ever drifts from what we render above.
+    void join(roots.configDir, 'project.json');
+    return lines;
+}
+/**
+ * Render a checkbox list of publishers and let the customer toggle which
+ * to enable in this install. Returns the selected publisher IDs.
+ *
+ * Controls:
+ *   ↑ / ↓     navigate
+ *   space     toggle the focused entry
+ *   a         toggle all
+ *   enter     confirm and exit
+ *   q / esc   cancel (returns the original `preselected` set)
+ *
+ * In non-TTY mode this throws — callers should catch and use --publisher /
+ * --all flags or fall back to a sensible default.
+ */
+export async function selectPublishers(available, preselected = []) {
+    if (!process.stdin.isTTY) {
+        throw new Error('selectPublishers: not a TTY (use --publisher or --all flags)');
+    }
+    if (available.length === 0)
+        return [];
+    const selected = new Set(preselected);
+    let cursor = 0;
+    const draw = () => {
+        process.stderr.write('\x1b[?25l'); // hide cursor
+        process.stderr.write(`\nYou have access to ${available.length} publishers. Which to enable in this project?\n\n`);
+        for (let i = 0; i < available.length; i++) {
+            const p = available[i];
+            const focused = i === cursor;
+            const checked = selected.has(p.id);
+            const box = checked ? '[x]' : '[ ]';
+            const arrow = focused ? '>' : ' ';
+            const skillSuffix = p.skillCount !== undefined ? `  — ${p.skillCount} skill${p.skillCount !== 1 ? 's' : ''}` : '';
+            process.stderr.write(`   ${arrow} ${box} ${p.name.padEnd(20)} ${skillSuffix}\n`);
+        }
+        process.stderr.write('\nSpace=toggle  a=toggle all  Enter=confirm  q=cancel\n');
+    };
+    const erase = () => {
+        // Clear the rendered lines so the next draw replaces them in place.
+        const lines = available.length + 4;
+        for (let i = 0; i < lines; i++) {
+            process.stderr.write('\x1b[1A\x1b[2K');
+        }
+    };
+    draw();
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        const cleanup = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener('data', onData);
+            process.stderr.write('\x1b[?25h'); // show cursor
+        };
+        const onData = (key) => {
+            if (key === '\u0003' || key === 'q' || key === '\u001b') {
+                // Ctrl-C, q, or Esc — cancel
+                erase();
+                cleanup();
+                resolve([...preselected]);
+                return;
+            }
+            if (key === '\r' || key === '\n') {
+                erase();
+                cleanup();
+                resolve([...selected]);
+                return;
+            }
+            if (key === ' ') {
+                const id = available[cursor]?.id;
+                if (id) {
+                    if (selected.has(id))
+                        selected.delete(id);
+                    else
+                        selected.add(id);
+                }
+            }
+            else if (key === 'a' || key === 'A') {
+                if (selected.size === available.length)
+                    selected.clear();
+                else
+                    for (const p of available)
+                        selected.add(p.id);
+            }
+            else if (key === '\u001b[A' || key === 'k') {
+                cursor = (cursor - 1 + available.length) % available.length;
+            }
+            else if (key === '\u001b[B' || key === 'j') {
+                cursor = (cursor + 1) % available.length;
+            }
+            erase();
+            draw();
+        };
+        stdin.on('data', onData);
+    });
+}
+/** Read a single keystroke from stdin. Used by confirmInstall. */
+function readSingleKey() {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        const onData = (key) => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener('data', onData);
+            resolve(key);
+        };
+        stdin.on('data', onData);
+    });
+}

package/dist/scope.js

@@ -0,0 +1,99 @@
+/**
+ * Install scope resolution.
+ *
+ * SkillVault supports two install scopes:
+ *   - "project": files live in the current working directory (./.skillvault, ./.claude)
+ *   - "global":  files live under the user's home directory (~/.skillvault, ~/.claude)
+ *
+ * Customer credentials (~/.skillvault/credentials.json) are ALWAYS global —
+ * they represent the user's identity, not the install. The scope only affects
+ * where vault data, project config, hooks, and skill stubs are written.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { loadCredentials, loadProjectConfig } from './credentials.js';
+import { getCurrentProject } from './projects-registry.js';
+/**
+ * Determine install scope from explicit flags and the current working directory.
+ *
+ * Priority:
+ *   1. --global flag → global
+ *   2. --project flag → project
+ *   3. CWD === $HOME or '/' → global (no sane "project" location)
+ *   4. Otherwise → project
+ */
+export function resolveScope(opts = {}) {
+    if (opts.global)
+        return 'global';
+    if (opts.project)
+        return 'project';
+    const cwd = opts.cwd ?? process.cwd();
+    const home = homedir();
+    if (cwd === home || cwd === '/')
+        return 'global';
+    return 'project';
+}
+/**
+ * Resolve filesystem roots for a given scope.
+ *
+ * For project scope, roots are based on `cwd` (defaults to process.cwd()).
+ * For global scope, roots are based on the user's home directory.
+ */
+export function resolveRoots(scope, cwd) {
+    if (scope === 'project') {
+        const base = cwd ?? process.cwd();
+        const configDir = join(base, '.skillvault');
+        const claudeDir = join(base, '.claude');
+        return {
+            scope,
+            configDir,
+            claudeDir,
+            vaultDir: join(configDir, 'vaults'),
+            settingsPath: join(claudeDir, 'settings.json'),
+        };
+    }
+    const home = homedir();
+    const configDir = join(home, '.skillvault');
+    const claudeDir = join(home, '.claude');
+    return {
+        scope,
+        configDir,
+        claudeDir,
+        vaultDir: join(configDir, 'vaults'),
+        settingsPath: join(claudeDir, 'settings.json'),
+    };
+}
+/**
+ * Always-global path to the customer credentials file.
+ * Credentials represent the user's identity and are never project-scoped.
+ */
+export function credentialsPath() {
+    return join(homedir(), '.skillvault', 'credentials.json');
+}
+/**
+ * Always-global path to the projects registry.
+ * Tracks every known project install path for `--all` operations.
+ */
+export function projectsRegistryPath() {
+    return join(homedir(), '.skillvault', 'projects.json');
+}
+/**
+ * Report the current install state at CWD.
+ *
+ * Resolves scope using the same rules as resolveScope() (no flags), looks
+ * up matching credentials, project config, and registry entry, and returns
+ * a single object suitable for the `--status` command and confirmation
+ * prompts. Fields that don't exist are returned as null/empty rather than
+ * throwing.
+ */
+export function reportInstallStatus(opts = {}) {
+    const scope = resolveScope(opts);
+    const roots = resolveRoots(scope, opts.cwd);
+    const credentials = loadCredentials();
+    const projectConfig = loadProjectConfig(roots);
+    const projectEntry = scope === 'project' ? getCurrentProject(opts.cwd) : null;
+    const activePublishers = projectConfig?.active_publishers
+        ?? projectEntry?.active_publishers
+        ?? [];
+    return { scope, roots, projectEntry, credentials, projectConfig, activePublishers };
+}

package/package.json

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