@devkitvault/recall 1.2.7 → 1.2.9

package/dist/commands/search.js

@@ -7,9 +7,7 @@ exports.searchCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const cli_table3_1 = __importDefault(require("cli-table3"));
 const commander_1 = require("commander");
-const ora_1 = __importDefault(require("ora"));
-const api_1 = require("../lib/api");
-const auth_1 = require("../lib/auth");
+const local_vault_1 = require("../lib/local-vault");
 function highlight(text, query) {
     if (!query)
         return text;
@@ -19,10 +17,8 @@ function highlight(text, query) {
 function fuzzyMatch(text, query) {
     const t = text.toLowerCase();
     const q = query.toLowerCase();
-    // exact substring match
     if (t.includes(q))
         return true;
-    // fuzzy — all chars of query appear in order in text
     let i = 0;
     for (const ch of t) {
         if (ch === q[i])
@@ -33,50 +29,39 @@ function fuzzyMatch(text, query) {
     return false;
 }
 exports.searchCommand = new commander_1.Command('search')
-    .description('Search your saved commands')
+    .description('Search your local vault')
     .argument('<query>', 'Search query')
     .option('-t, --tag <tag>', 'Filter by tag')
     .action(async (query, opts) => {
-    const token = await (0, auth_1.requireAuth)();
-    const spinner = (0, ora_1.default)('Searching...').start();
-    try {
-        const params = new URLSearchParams();
-        if (opts.tag)
-            params.set('tag', opts.tag);
-        const { commands } = await api_1.ApiClient.get(`/commands?${params}`, token);
-        spinner.stop();
-        // Fuzzy filter locally
-        const results = commands.filter((cmd) => {
-            return (fuzzyMatch(cmd.command, query) ||
-                (cmd.name && fuzzyMatch(cmd.name, query)) ||
-                (cmd.tags && cmd.tags.some((t) => fuzzyMatch(t, query))));
-        });
-        if (!results.length) {
-            console.log(chalk_1.default.dim(`\n  No commands found matching "${query}".\n`));
-            return;
-        }
-        console.log(chalk_1.default.dim(`\n  ${results.length} result${results.length === 1 ? '' : 's'} for "${chalk_1.default.white(query)}"\n`));
-        const table = new cli_table3_1.default({
-            head: [chalk_1.default.cyan('Name'), chalk_1.default.cyan('Command'), chalk_1.default.cyan('Tags')],
-            style: { head: [], border: ['grey'] },
-            colWidths: [20, 46, 18],
-            wordWrap: true,
-        });
-        for (const cmd of results) {
-            const name = cmd.name ?? '—';
-            const command = cmd.command.length > 44
-                ? cmd.command.slice(0, 44) + '…'
-                : cmd.command;
-            const tags = (cmd.tags ?? []).join(', ') || '—';
-            table.push([
-                highlight(name, query),
-                highlight(command, query),
-                highlight(tags, query),
-            ]);
-        }
-        console.log(table.toString());
+    const commands = (0, local_vault_1.listLocalCommands)({ tag: opts.tag });
+    const results = commands.filter((cmd) => {
+        return (fuzzyMatch(cmd.command, query) ||
+            (cmd.name ? fuzzyMatch(cmd.name, query) : false) ||
+            (cmd.tags ?? []).some((t) => fuzzyMatch(t, query)));
+    });
+    if (!results.length) {
+        console.log(chalk_1.default.dim(`\n  No local commands matching "${query}".\n`));
+        return;
     }
-    catch {
-        spinner.fail(chalk_1.default.red('Search failed'));
+    console.log(chalk_1.default.dim(`\n  ${results.length} result${results.length === 1 ? '' : 's'} for "${chalk_1.default.white(query)}"\n`));
+    const table = new cli_table3_1.default({
+        head: [chalk_1.default.cyan('Name'), chalk_1.default.cyan('Command'), chalk_1.default.cyan('Tags')],
+        style: { head: [], border: ['grey'] },
+        colWidths: [20, 46, 18],
+        wordWrap: true,
+    });
+    for (const cmd of results) {
+        const name = cmd.name ?? '—';
+        const command = cmd.command.length > 44
+            ? cmd.command.slice(0, 44) + '…'
+            : cmd.command;
+        const tags = (cmd.tags ?? []).join(', ') || '—';
+        table.push([
+            highlight(name, query),
+            highlight(command, query),
+            highlight(tags, query),
+        ]);
     }
+    console.log(table.toString());
+    console.log();
 });

package/dist/commands/sync.js

@@ -7,74 +7,112 @@ exports.syncCommand = void 0;
 exports.getCachedCommands = getCachedCommands;
 const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
-const fs_1 = __importDefault(require("fs"));
 const ora_1 = __importDefault(require("ora"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
 const api_1 = require("../lib/api");
 const auth_1 = require("../lib/auth");
-const CACHE_DIR = path_1.default.join(os_1.default.homedir(), '.recall');
-const CACHE_FILE = path_1.default.join(CACHE_DIR, 'commands.json');
-function writeCache(commands) {
-    fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
-    fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify({
-        syncedAt: new Date().toISOString(),
-        commands,
-    }, null, 2));
-}
-function readCache() {
-    try {
-        if (!fs_1.default.existsSync(CACHE_FILE))
-            return null;
-        return JSON.parse(fs_1.default.readFileSync(CACHE_FILE, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-function getCachedCommands() {
-    const cache = readCache();
-    return cache?.commands ?? [];
-}
+const local_vault_1 = require("../lib/local-vault");
 exports.syncCommand = new commander_1.Command('sync')
-    .description('Sync commands from server to local cache')
-    .option('-s, --status', 'Show last sync status without syncing')
+    .description('Sync local vault ↔ cloud (Pro/Team)')
+    .option('-s, --status', 'Show local vault + last sync status')
+    .option('--pull', 'Pull cloud → local only')
+    .option('--push', 'Push local-only commands → cloud only')
     .action(async (opts) => {
-    // Just show status
+    const vault = (0, local_vault_1.readVault)();
     if (opts.status) {
-        const cache = readCache();
-        if (!cache) {
-            console.log(chalk_1.default.dim('\n  Never synced. Run: recall sync\n'));
-            return;
-        }
-        const ago = Math.round((Date.now() - new Date(cache.syncedAt).getTime()) / 1000 / 60);
         console.log();
-        console.log(`  Last synced: ${chalk_1.default.white(ago < 1 ? 'just now' : `${ago} minutes ago`)}`);
-        console.log(`  Commands:   ${chalk_1.default.white(cache.commands.length)} cached locally`);
-        console.log(`  Cache file: ${chalk_1.default.dim(CACHE_FILE)}`);
+        console.log(`  Local commands: ${chalk_1.default.white(vault.commands.length)}`);
+        console.log(`  Vault file:     ${chalk_1.default.dim(local_vault_1.VAULT_FILE)}`);
+        if (!vault.syncedAt) {
+            console.log(chalk_1.default.dim('  Never synced to cloud.'));
+        }
+        else {
+            const ago = Math.round((Date.now() - new Date(vault.syncedAt).getTime()) / 1000 / 60);
+            console.log(`  Last synced:    ${chalk_1.default.white(ago < 1 ? 'just now' : `${ago} minutes ago`)}`);
+        }
+        const pending = (0, local_vault_1.localCommandsNeedingPush)().length;
+        if (pending) {
+            console.log(`  Not on cloud:   ${chalk_1.default.yellow(String(pending))} (recall sync --push)`);
+        }
         console.log();
         return;
     }
+    const doPull = opts.pull || (!opts.pull && !opts.push);
+    const doPush = opts.push || (!opts.pull && !opts.push);
     const token = await (0, auth_1.requireAuth)();
-    const spinner = (0, ora_1.default)('Syncing from server...').start();
+    const spinner = (0, ora_1.default)('Checking plan...').start();
     try {
-        const { commands } = await api_1.ApiClient.get('/commands', token);
-        writeCache(commands);
-        spinner.succeed(chalk_1.default.green(`Synced ${commands.length} command${commands.length === 1 ? '' : 's'}`));
-        console.log();
-        console.log(`  ${chalk_1.default.dim('Cached to:')} ${chalk_1.default.dim(CACHE_FILE)}`);
-        if (commands.length) {
-            console.log();
-            console.log(chalk_1.default.dim('  Commands available offline:'));
-            for (const cmd of commands) {
-                const name = cmd.name ? chalk_1.default.white(cmd.name) : chalk_1.default.dim('unnamed');
-                console.log(`    · ${name}  ${chalk_1.default.dim(cmd.command.slice(0, 50))}`);
+        const { user } = await api_1.ApiClient.get('/auth/me', token);
+        const plan = (user.plan ?? 'free');
+        spinner.stop();
+        if (plan !== 'pro' && plan !== 'team') {
+            console.log(chalk_1.default.yellow('\n  Cloud sync requires Pro or Team.'));
+            console.log(chalk_1.default.dim('  Local vault still works without sync.'));
+            console.log(chalk_1.default.dim('  Upgrade: recall upgrade\n'));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk_1.default.red('Could not verify plan'));
+        if (err instanceof api_1.ApiError && err.status === 401) {
+            console.log(chalk_1.default.red('\n  Session expired. Run: recall auth login\n'));
+        }
+        process.exit(1);
+    }
+    let pulled = 0;
+    let pushed = 0;
+    if (doPull) {
+        const pullSpinner = (0, ora_1.default)('Pulling from cloud...').start();
+        try {
+            const { commands } = await api_1.ApiClient.get('/commands', token);
+            const { added, updated } = (0, local_vault_1.mergeCloudIntoLocal)(commands);
+            pulled = added + updated;
+            pullSpinner.succeed(chalk_1.default.green(`Pulled cloud vault (${added} new, ${updated} updated)`));
+        }
+        catch (err) {
+            pullSpinner.fail(chalk_1.default.red('Pull failed'));
+            if (err instanceof api_1.ApiError && err.status === 403) {
+                console.log(chalk_1.default.yellow('\n  Cloud vault requires Pro.\n'));
+            }
+            process.exit(1);
+        }
+    }
+    if (doPush) {
+        const pending = (0, local_vault_1.localCommandsNeedingPush)();
+        if (!pending.length) {
+            console.log(chalk_1.default.dim('  Nothing new to push.'));
+        }
+        else {
+            const pushSpinner = (0, ora_1.default)(`Pushing ${pending.length} local command(s)...`).start();
+            try {
+                for (const cmd of pending) {
+                    const saved = await api_1.ApiClient.post('/commands', {
+                        command: cmd.command,
+                        name: cmd.name,
+                        tags: cmd.tags,
+                    }, token);
+                    if (saved?.id)
+                        (0, local_vault_1.attachCloudId)(cmd.id, saved.id);
+                    pushed++;
+                }
+                pushSpinner.succeed(chalk_1.default.green(`Pushed ${pushed} command${pushed === 1 ? '' : 's'} to cloud`));
+            }
+            catch (err) {
+                pushSpinner.fail(chalk_1.default.red('Push failed'));
+                if (err instanceof api_1.ApiError && err.status === 403) {
+                    console.log(chalk_1.default.yellow('\n  Cloud save requires Pro. Local vault is unchanged.\n'));
+                }
+                process.exit(1);
             }
         }
-        console.log();
     }
-    catch {
-        spinner.fail(chalk_1.default.red('Sync failed'));
-        console.log(chalk_1.default.dim('\n  Make sure you are logged in and the API is reachable.\n'));
+    console.log();
+    console.log(`  ${chalk_1.default.dim('Local vault:')} ${chalk_1.default.dim(local_vault_1.VAULT_FILE)}`);
+    if (doPull || doPush) {
+        console.log(chalk_1.default.dim(`  pull≈${pulled} · push=${pushed}`));
     }
+    console.log();
 });
+/** @deprecated kept for any imports — use readVault */
+function getCachedCommands() {
+    return (0, local_vault_1.readVault)().commands;
+}

package/dist/commands/upgrade.js

@@ -16,18 +16,17 @@ const PLANS = {
         label: 'Free',
         price: '$0/month',
         features: [
-            '20 AI asks / month',
-            '3 playbooks',
-            '100 command saves',
-            'Search and filter',
-            'Export as JSON or shell script',
-            'Cross-machine sync',
+            'Fully local vault (no account)',
+            'Save, list, search, run on your machine',
+            'No cloud sync',
+            'No AI Ask (Pro)',
         ],
     },
     pro: {
         label: 'Pro',
         price: '$6/month',
         features: [
+            'Sync local ↔ cloud',
             '500 AI asks / month',
             'Unlimited playbooks',
             'Unlimited commands',

package/dist/commands/whoami.js

@@ -16,13 +16,13 @@ const PLAN_LABELS = {
 };
 const PLAN_FEATURES = {
     free: [
-        'Unlimited command saves',
-        'Search and filter',
-        'Export as JSON or shell script',
-        'Cross-machine sync',
+        'Fully local vault (no cloud)',
+        'Save, list, search, run offline',
+        'No Ask / no sync',
     ],
     pro: [
-        'Everything in Free',
+        'Sync local ↔ cloud',
+        'Ask (NL, print-only)',
         'Command groups',
         'Share commands via link',
     ],
@@ -30,7 +30,6 @@ const PLAN_FEATURES = {
         'Everything in Pro',
         'Org-level vaults',
         'Role-based access',
-        'SSO / SAML',
         'Audit log',
     ],
 };
@@ -59,8 +58,8 @@ exports.whoamiCommand = new commander_1.Command('whoami')
         }
         if (plan === 'free') {
             console.log();
-            console.log(chalk_1.default.dim('  Upgrade to Pro for groups and sharing:'));
-            console.log(chalk_1.default.dim('  https://devkitvault.com/recall/upgrade'));
+            console.log(chalk_1.default.dim('  Upgrade to Pro for sync + Ask:'));
+            console.log(chalk_1.default.dim('  https://recall.devkitvault.com/dashboard/upgrade'));
         }
         console.log();
     }

package/dist/lib/config.js

@@ -11,7 +11,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.recall');
 const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
-exports.APP_VERSION = "2.6.0";
+exports.APP_VERSION = '1.2.9';
 exports.ENVIRONMENTS = {
     production: 'https://api.devkitvault.com',
     local: 'http://127.0.0.1:3001',

package/dist/lib/local-vault.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VAULT_FILE = void 0;
+exports.readVault = readVault;
+exports.writeVault = writeVault;
+exports.listLocalCommands = listLocalCommands;
+exports.findLocalByName = findLocalByName;
+exports.saveLocalCommand = saveLocalCommand;
+exports.deleteLocalByName = deleteLocalByName;
+exports.setLocalPinned = setLocalPinned;
+exports.markVaultSynced = markVaultSynced;
+exports.replaceLocalFromCloud = replaceLocalFromCloud;
+exports.mergeCloudIntoLocal = mergeCloudIntoLocal;
+exports.localCommandsNeedingPush = localCommandsNeedingPush;
+exports.attachCloudId = attachCloudId;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const VAULT_DIR = node_path_1.default.join(process.env.RECALL_HOME?.trim() || node_os_1.default.homedir(), '.recall');
+exports.VAULT_FILE = node_path_1.default.join(VAULT_DIR, 'commands.json');
+function nowIso() {
+    return new Date().toISOString();
+}
+function ensureDir() {
+    node_fs_1.default.mkdirSync(VAULT_DIR, { recursive: true });
+}
+function normalizeCommand(raw, legacySyncCache) {
+    const command = String(raw.command ?? '');
+    const name = typeof raw.name === 'string' && raw.name.trim() ? raw.name.trim() : undefined;
+    const tags = Array.isArray(raw.tags)
+        ? raw.tags.filter((t) => typeof t === 'string' && t.trim().length > 0)
+        : undefined;
+    const pinned = Boolean(raw.pinned);
+    const createdAt = typeof raw.createdAt === 'string' ? raw.createdAt : nowIso();
+    const updatedAt = typeof raw.updatedAt === 'string' ? raw.updatedAt : createdAt;
+    let cloudId;
+    if (typeof raw.cloudId === 'string' && raw.cloudId) {
+        cloudId = raw.cloudId;
+    }
+    else if (legacySyncCache && typeof raw.id === 'string' && raw.id) {
+        // Old cache used API ids as `id`
+        cloudId = raw.id;
+    }
+    const id = !legacySyncCache && typeof raw.id === 'string' && raw.id
+        ? raw.id
+        : (0, node_crypto_1.randomUUID)();
+    return {
+        id,
+        command,
+        name,
+        tags: tags?.length ? tags : undefined,
+        pinned: pinned || undefined,
+        createdAt,
+        updatedAt,
+        cloudId,
+    };
+}
+function emptyVault() {
+    return {
+        version: 1,
+        updatedAt: nowIso(),
+        syncedAt: null,
+        commands: [],
+    };
+}
+function readVault() {
+    try {
+        if (!node_fs_1.default.existsSync(exports.VAULT_FILE))
+            return emptyVault();
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(exports.VAULT_FILE, 'utf-8'));
+        const rawCommands = Array.isArray(parsed.commands) ? parsed.commands : [];
+        const legacySyncCache = parsed.version !== 1;
+        const commands = rawCommands
+            .filter((c) => c !== null && typeof c === 'object')
+            .map((c) => normalizeCommand(c, legacySyncCache))
+            .filter((c) => c.command.trim().length > 0);
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : nowIso(),
+            syncedAt: typeof parsed.syncedAt === 'string' ? parsed.syncedAt : null,
+            commands,
+        };
+    }
+    catch {
+        return emptyVault();
+    }
+}
+function writeVault(vault) {
+    ensureDir();
+    const payload = {
+        version: 1,
+        updatedAt: nowIso(),
+        syncedAt: vault.syncedAt ?? null,
+        commands: vault.commands,
+    };
+    node_fs_1.default.writeFileSync(exports.VAULT_FILE, JSON.stringify(payload, null, 2), { mode: 0o600 });
+}
+function listLocalCommands(filters) {
+    let rows = readVault().commands;
+    if (filters?.tag) {
+        const tag = filters.tag.toLowerCase();
+        rows = rows.filter((c) => (c.tags ?? []).some((t) => t.toLowerCase() === tag));
+    }
+    if (filters?.search) {
+        const q = filters.search.toLowerCase();
+        rows = rows.filter((c) => c.command.toLowerCase().includes(q) ||
+            (c.name?.toLowerCase().includes(q) ?? false) ||
+            (c.tags ?? []).some((t) => t.toLowerCase().includes(q)));
+    }
+    if (filters?.pinned) {
+        rows = rows.filter((c) => c.pinned);
+    }
+    return rows.sort((a, b) => {
+        if (a.pinned && !b.pinned)
+            return -1;
+        if (!a.pinned && b.pinned)
+            return 1;
+        return b.updatedAt.localeCompare(a.updatedAt);
+    });
+}
+function findLocalByName(name) {
+    const needle = name.toLowerCase();
+    return readVault().commands.find((c) => c.name?.toLowerCase() === needle);
+}
+function saveLocalCommand(input) {
+    const vault = readVault();
+    const stamp = nowIso();
+    const name = input.name?.trim() || undefined;
+    if (name) {
+        const existing = vault.commands.find((c) => c.name?.toLowerCase() === name.toLowerCase());
+        if (existing) {
+            existing.command = input.command;
+            existing.tags = input.tags?.length ? input.tags : undefined;
+            existing.updatedAt = stamp;
+            // Local edit invalidates cloud link until next push maps again
+            writeVault(vault);
+            return existing;
+        }
+    }
+    const saved = {
+        id: (0, node_crypto_1.randomUUID)(),
+        command: input.command,
+        name,
+        tags: input.tags?.length ? input.tags : undefined,
+        createdAt: stamp,
+        updatedAt: stamp,
+    };
+    vault.commands.push(saved);
+    writeVault(vault);
+    return saved;
+}
+function deleteLocalByName(name) {
+    const vault = readVault();
+    const idx = vault.commands.findIndex((c) => c.name?.toLowerCase() === name.toLowerCase());
+    if (idx < 0)
+        return undefined;
+    const [removed] = vault.commands.splice(idx, 1);
+    writeVault(vault);
+    return removed;
+}
+function setLocalPinned(name, pinned) {
+    const vault = readVault();
+    const cmd = vault.commands.find((c) => c.name?.toLowerCase() === name.toLowerCase());
+    if (!cmd)
+        return undefined;
+    cmd.pinned = pinned || undefined;
+    cmd.updatedAt = nowIso();
+    writeVault(vault);
+    return cmd;
+}
+function markVaultSynced(at = nowIso()) {
+    const vault = readVault();
+    vault.syncedAt = at;
+    writeVault(vault);
+}
+function replaceLocalFromCloud(cloudCommands) {
+    const stamp = nowIso();
+    const mapped = cloudCommands.map((c) => ({
+        id: (0, node_crypto_1.randomUUID)(),
+        cloudId: c.id,
+        command: c.command,
+        name: c.name ?? undefined,
+        tags: c.tags?.length ? c.tags : undefined,
+        pinned: c.pinned || undefined,
+        createdAt: c.createdAt ?? stamp,
+        updatedAt: c.updatedAt ?? stamp,
+    }));
+    writeVault({
+        version: 1,
+        updatedAt: stamp,
+        syncedAt: stamp,
+        commands: mapped,
+    });
+    return mapped;
+}
+/** Merge cloud into local by name (cloud wins on conflict); keep local-only rows. */
+function mergeCloudIntoLocal(cloudCommands) {
+    const vault = readVault();
+    const stamp = nowIso();
+    let added = 0;
+    let updated = 0;
+    for (const cloud of cloudCommands) {
+        const name = cloud.name?.trim();
+        const byCloudId = vault.commands.find((c) => c.cloudId === cloud.id);
+        const byName = name
+            ? vault.commands.find((c) => c.name?.toLowerCase() === name.toLowerCase())
+            : undefined;
+        const target = byCloudId ?? byName;
+        if (target) {
+            target.cloudId = cloud.id;
+            target.command = cloud.command;
+            target.name = name || target.name;
+            target.tags = cloud.tags?.length ? cloud.tags : undefined;
+            target.pinned = cloud.pinned || undefined;
+            target.updatedAt = stamp;
+            updated++;
+        }
+        else {
+            vault.commands.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                cloudId: cloud.id,
+                command: cloud.command,
+                name: name || undefined,
+                tags: cloud.tags?.length ? cloud.tags : undefined,
+                pinned: cloud.pinned || undefined,
+                createdAt: cloud.createdAt ?? stamp,
+                updatedAt: stamp,
+            });
+            added++;
+        }
+    }
+    vault.syncedAt = stamp;
+    writeVault(vault);
+    return { local: vault.commands, added, updated };
+}
+function localCommandsNeedingPush() {
+    return readVault().commands.filter((c) => !c.cloudId);
+}
+function attachCloudId(localId, cloudId) {
+    const vault = readVault();
+    const cmd = vault.commands.find((c) => c.id === localId);
+    if (!cmd)
+        return;
+    cmd.cloudId = cloudId;
+    cmd.updatedAt = nowIso();
+    writeVault(vault);
+}