@devkitvault/recall 1.2.10 → 1.2.11

package/README.md

@@ -1,10 +1,13 @@
 # @devkitvault/recall
 
-**recall** is a CLI command vault for your terminal. Save the commands you keep losing, search them, run them by name, and sync when you want cloud backup.
+I kept losing useful shell commands. So I built a small vault for the ones I actually reuse.
 
-Product site and docs: [recall.devkitvault.com](https://recall.devkitvault.com)
+**recall** saves commands locally, lets you search and run them by name, and optionally syncs when you want the same vault on another machine.
 
-Open source: [github.com/devkitvault/recall-cli](https://github.com/devkitvault/recall-cli)
+- **Free:** local vault only — no account, nothing uploads (`~/.recall/commands.json`)
+- **Pro / Team:** `recall sync` + Ask (prints a suggestion; never runs it)
+
+Product: [recall.devkitvault.com](https://recall.devkitvault.com) · Docs: [docs](https://recall.devkitvault.com/docs)
 
 ## Requirements
 
@@ -23,45 +26,43 @@ recall --version
 recall doctor
 ```
 
-## Quick start (local vault)
+## Quick start (Free — local)
 
-Local save / list / search / run work **without an account**. Auth is only needed for **sync**, **Ask** (Pro/Team), and team features.
+No account needed.
 
 ```sh
-recall save "docker compose up -d" --name docker --tags docker
+recall save "docker compose up -d" -n up -t docker
 recall save --last -n useful -t docker
-recall import history
+recall import history -n 20
 recall list
 recall search docker
-recall run docker
+recall run up
 ```
 
-`recall import history` reads your shell history file (zsh/bash/PowerShell), lets you pick commands, and saves them locally. It does **not** install a keylogger or live hook.
+`recall import history` reads your shell history file (zsh / bash / PowerShell) and lets you pick what to keep. It does not sit in the background recording keystrokes.
 
-`recall save --last` (or `-L`) reads the last line from zsh / bash / PowerShell history. Not supported in Windows `cmd.exe`. On bash, if the command is missing: `history -a && recall save --last`.
+`recall save --last` (or `-L`) takes the last history line. Not supported in Windows `cmd.exe`. On bash, if it’s empty: `history -a && recall save --last`.
 
 ```sh
 recall playbook save deploy "docker compose up -d" "pnpm migrate"
 recall playbook run deploy --dry-run
 ```
 
-Local playbooks follow the same idea when available; cloud playbooks need Pro. `recall playbook run` executes steps. Ask never does.
+`recall playbook run` executes steps. Ask never does.
 
 ## Ask (Pro / Team)
 
-Natural-language Ask prints a suggestion and never runs it. Requires a Pro or Team plan.
-
 ```sh
 recall auth login
 recall "find the 10 biggest files in this directory"
 rec "that docker command from last week"
 ```
 
-No-args `recall` opens an Ask session (`Recall >`). `/save [name]` stores the last suggestion. `/exit` leaves.
+Ask only prints. You run the command yourself.
 
-## Auth & sync (Pro / Team)
+No-args `recall` opens an Ask session (`Recall >`). `/save [name]` stores the last suggestion. `/exit` leaves.
 
-Account + Pro/Team syncs your **local** commands to the cloud and unlocks Ask.
+## Sync (Pro / Team)
 
 ```sh
 recall auth login
@@ -71,12 +72,13 @@ recall sync --push   # local-only → cloud
 recall sync --status
 recall whoami
 ```
-## Prefer a standalone binary?
+
+## Native binary (optional)
 
 - **macOS / Linux:** `curl -fsSL https://devkitvault.com/recall/install.sh | sh`
 - **Windows:** `irm https://devkitvault.com/recall/install.ps1 | iex`
 
-See [recall.devkitvault.com/docs/install](https://recall.devkitvault.com/docs/install).
+See [install docs](https://recall.devkitvault.com/docs/install).
 
 ## Update
 
@@ -91,18 +93,17 @@ recall doctor
 recall whoami
 ```
 
-If something still fails, open an issue on [GitHub](https://github.com/devkitvault/recall-cli/issues) or visit [recall.devkitvault.com](https://recall.devkitvault.com).
+Issues: [github.com/devkitvaultorg/recall-cli/issues](https://github.com/devkitvaultorg/recall-cli/issues)
 
 ## Links
 
-|           |                                                                                           |
+| | |
 | --------- | ----------------------------------------------------------------------------------------- |
-| Website   | [recall.devkitvault.com](https://recall.devkitvault.com)                                  |
-| Docs      | [recall.devkitvault.com/docs](https://recall.devkitvault.com/docs)                        |
-| Dashboard | [recall.devkitvault.com](https://recall.devkitvault.com)                                  |
-| Source    | [github.com/devkitvault/recall-cli](https://github.com/devkitvault/recall-cli)            |
-| VS Code   | [Marketplace](https://marketplace.visualstudio.com/items?itemName=devkitvault.recall-cmd) |
-| Issues    | [github.com/devkitvault/recall-cli](https://github.com/devkitvault/recall-cli/issues)     |
+| Website | [recall.devkitvault.com](https://recall.devkitvault.com) |
+| Docs | [recall.devkitvault.com/docs](https://recall.devkitvault.com/docs) |
+| Source | [github.com/devkitvaultorg/recall-cli](https://github.com/devkitvaultorg/recall-cli) |
+| npm | [@devkitvault/recall](https://www.npmjs.com/package/@devkitvault/recall) |
+| VS Code | [Marketplace](https://marketplace.visualstudio.com/items?itemName=devkitvault.recall-cmd) |
 
 ## License
 

package/dist/commands/sync.js

@@ -10,29 +10,47 @@ 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_collections_1 = require("../lib/local-collections");
 const local_vault_1 = require("../lib/local-vault");
 exports.syncCommand = new commander_1.Command('sync')
     .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')
+    .option('--push', 'Push local-only items → cloud only')
     .action(async (opts) => {
     const vault = (0, local_vault_1.readVault)();
     if (opts.status) {
+        const groups = (0, local_collections_1.listLocalGroups)().length;
+        const templates = (0, local_collections_1.listLocalTemplates)().length;
+        const snippets = (0, local_collections_1.listLocalSnippets)().length;
+        const envSets = (0, local_collections_1.listLocalEnvSets)().length;
+        const aliases = (0, local_collections_1.listLocalAliases)().length;
         console.log();
-        console.log(`  Local commands: ${chalk_1.default.white(vault.commands.length)}`);
-        console.log(`  Vault file:     ${chalk_1.default.dim(local_vault_1.VAULT_FILE)}`);
+        console.log(chalk_1.default.white('  Local vault (Free soft caps)'));
+        console.log(`  Commands:   ${chalk_1.default.white(vault.commands.length)}/${local_collections_1.LOCAL_SOFT_CAPS.commands}`);
+        console.log(`  Groups:     ${chalk_1.default.white(groups)}/${local_collections_1.LOCAL_SOFT_CAPS.groups}`);
+        console.log(`  Templates:  ${chalk_1.default.white(templates)}/${local_collections_1.LOCAL_SOFT_CAPS.templates}`);
+        console.log(`  Snippets:   ${chalk_1.default.white(snippets)}/${local_collections_1.LOCAL_SOFT_CAPS.snippets}`);
+        console.log(`  Env sets:   ${chalk_1.default.white(envSets)}/${local_collections_1.LOCAL_SOFT_CAPS.envSets}`);
+        console.log(`  Aliases:    ${chalk_1.default.white(aliases)}/${local_collections_1.LOCAL_SOFT_CAPS.aliases}`);
+        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`)}`);
+            console.log(`  Last synced: ${chalk_1.default.white(ago < 1 ? 'just now' : `${ago} minutes ago`)}`);
         }
-        const pending = (0, local_vault_1.localCommandsNeedingPush)().length;
+        const pending = (0, local_vault_1.localCommandsNeedingPush)().length +
+            (0, local_collections_1.groupsNeedingPush)().length +
+            (0, local_collections_1.templatesNeedingPush)().length +
+            (0, local_collections_1.snippetsNeedingPush)().length +
+            (0, local_collections_1.envSetsNeedingPush)().length +
+            (0, local_collections_1.aliasesNeedingPush)().length;
         if (pending) {
-            console.log(`  Not on cloud:   ${chalk_1.default.yellow(String(pending))} (recall sync --push)`);
+            console.log(`  Not on cloud: ${chalk_1.default.yellow(String(pending))} (recall sync --push)`);
         }
+        console.log(chalk_1.default.dim('  Sync requires Pro/Team. Free cloud quota is always 0.'));
         console.log();
         return;
     }
@@ -44,9 +62,11 @@ exports.syncCommand = new commander_1.Command('sync')
         const { user } = await api_1.ApiClient.get('/auth/me', token);
         const plan = (user.plan ?? 'free');
         spinner.stop();
+        // Anti-scam: never sync on Free — cloud Free quotas are 0
         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('  Free accounts cannot push to cloud (anti-abuse).'));
             console.log(chalk_1.default.dim('  Upgrade: recall upgrade\n'));
             process.exit(1);
         }
@@ -64,9 +84,56 @@ exports.syncCommand = new commander_1.Command('sync')
         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)`));
+            const cmdMerge = (0, local_vault_1.mergeCloudIntoLocal)(commands);
+            pulled += cmdMerge.added + cmdMerge.updated;
+            try {
+                const { groups } = await api_1.ApiClient.get('/groups', token);
+                const g = (0, local_collections_1.mergeCloudGroups)(groups ?? []);
+                pulled += g.added + g.updated;
+            }
+            catch {
+                /* Free/legacy — ignore */
+            }
+            try {
+                const { templates } = await api_1.ApiClient.get('/templates', token);
+                const t = (0, local_collections_1.mergeCloudTemplates)(templates ?? []);
+                pulled += t.added + t.updated;
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                const { snippets } = await api_1.ApiClient.get('/snippets', token);
+                const s = (0, local_collections_1.mergeCloudSnippets)(snippets ?? []);
+                pulled += s.added + s.updated;
+            }
+            catch {
+                /* ignore */
+            }
+            // Env list omits vars — fetch each by name
+            try {
+                const { envSets } = await api_1.ApiClient.get('/env', token);
+                const full = [];
+                for (const e of envSets ?? []) {
+                    try {
+                        const row = await api_1.ApiClient.get(`/env/${encodeURIComponent(e.name)}`, token);
+                        full.push({
+                            id: row.id,
+                            name: row.name,
+                            vars: row.vars ?? {},
+                        });
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+                const em = (0, local_collections_1.mergeCloudEnvSets)(full);
+                pulled += em.added + em.updated;
+            }
+            catch {
+                /* ignore */
+            }
+            pullSpinner.succeed(chalk_1.default.green(`Pulled cloud vault (≈${pulled} changes)`));
         }
         catch (err) {
             pullSpinner.fail(chalk_1.default.red('Pull failed'));
@@ -77,32 +144,76 @@ exports.syncCommand = new commander_1.Command('sync')
         }
     }
     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`));
+        const pushSpinner = (0, ora_1.default)('Pushing local items...').start();
+        try {
+            for (const cmd of (0, local_vault_1.localCommandsNeedingPush)()) {
+                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++;
+            }
+            for (const g of (0, local_collections_1.groupsNeedingPush)()) {
+                const saved = await api_1.ApiClient.post('/groups', { name: g.name }, token);
+                if (saved?.id)
+                    (0, local_collections_1.attachGroupCloudId)(g.id, saved.id);
+                pushed++;
             }
-            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'));
+            for (const t of (0, local_collections_1.templatesNeedingPush)()) {
+                const saved = await api_1.ApiClient.post('/templates', { name: t.name, template: t.template, tags: t.tags ?? [] }, token);
+                if (saved?.id)
+                    (0, local_collections_1.attachTemplateCloudId)(t.id, saved.id);
+                pushed++;
+            }
+            for (const s of (0, local_collections_1.snippetsNeedingPush)()) {
+                const saved = await api_1.ApiClient.post('/snippets', { name: s.name, content: s.content, tags: s.tags ?? [] }, token);
+                if (saved?.id)
+                    (0, local_collections_1.attachSnippetCloudId)(s.id, saved.id);
+                pushed++;
+            }
+            for (const e of (0, local_collections_1.envSetsNeedingPush)()) {
+                const saved = await api_1.ApiClient.post('/env', { name: e.name, vars: e.vars }, token);
+                // Env upsert may return without id — treat name as synced marker via cloudId if present
+                if (saved?.id)
+                    (0, local_collections_1.attachEnvCloudId)(e.id, saved.id);
+                else if (saved?.name)
+                    (0, local_collections_1.attachEnvCloudId)(e.id, saved.name);
+                pushed++;
+            }
+            // Aliases need cloud commandId — resolve via local command's cloudId
+            for (const a of (0, local_collections_1.aliasesNeedingPush)()) {
+                const localCmd = (0, local_vault_1.listLocalCommands)().find((c) => c.id === a.localCommandId);
+                const cloudCommandId = localCmd?.cloudId ??
+                    (localCmd?.name ? (0, local_vault_1.findLocalByName)(localCmd.name)?.cloudId : undefined);
+                if (!cloudCommandId) {
+                    continue; // skip until command is synced
                 }
-                process.exit(1);
+                const saved = await api_1.ApiClient.post('/aliases', { alias: a.alias, commandId: cloudCommandId }, token);
+                if (saved?.id)
+                    (0, local_collections_1.attachAliasCloudId)(a.id, saved.id);
+                else
+                    (0, local_collections_1.attachAliasCloudId)(a.id, a.alias);
+                pushed++;
+            }
+            if (!pushed) {
+                pushSpinner.succeed(chalk_1.default.dim('Nothing new to push'));
             }
+            else {
+                pushSpinner.succeed(chalk_1.default.green(`Pushed ${pushed} item${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 blocked (plan limit or Free). Local vault unchanged.\n'));
+            }
+            else if (err instanceof Error) {
+                console.log(chalk_1.default.red(`\n  ${err.message}\n`));
+            }
+            process.exit(1);
         }
     }
     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 = '1.2.10';
+exports.APP_VERSION = '1.2.11';
 exports.ENVIRONMENTS = {
     production: 'https://api.devkitvault.com',
     local: 'http://127.0.0.1:3001',

package/dist/lib/local-collections.js

@@ -0,0 +1,617 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalVaultSizeError = exports.LocalVaultLimitError = exports.LOCAL_SIZE_LIMITS = exports.LOCAL_SOFT_CAPS = void 0;
+exports.listLocalGroups = listLocalGroups;
+exports.saveLocalGroup = saveLocalGroup;
+exports.deleteLocalGroup = deleteLocalGroup;
+exports.renameLocalGroup = renameLocalGroup;
+exports.groupsNeedingPush = groupsNeedingPush;
+exports.attachGroupCloudId = attachGroupCloudId;
+exports.mergeCloudGroups = mergeCloudGroups;
+exports.listLocalTemplates = listLocalTemplates;
+exports.saveLocalTemplate = saveLocalTemplate;
+exports.updateLocalTemplate = updateLocalTemplate;
+exports.deleteLocalTemplate = deleteLocalTemplate;
+exports.templatesNeedingPush = templatesNeedingPush;
+exports.attachTemplateCloudId = attachTemplateCloudId;
+exports.mergeCloudTemplates = mergeCloudTemplates;
+exports.listLocalSnippets = listLocalSnippets;
+exports.saveLocalSnippet = saveLocalSnippet;
+exports.updateLocalSnippet = updateLocalSnippet;
+exports.deleteLocalSnippet = deleteLocalSnippet;
+exports.snippetsNeedingPush = snippetsNeedingPush;
+exports.attachSnippetCloudId = attachSnippetCloudId;
+exports.mergeCloudSnippets = mergeCloudSnippets;
+exports.listLocalEnvSets = listLocalEnvSets;
+exports.saveLocalEnvSet = saveLocalEnvSet;
+exports.deleteLocalEnvSet = deleteLocalEnvSet;
+exports.updateLocalEnvSet = updateLocalEnvSet;
+exports.envSetsNeedingPush = envSetsNeedingPush;
+exports.attachEnvCloudId = attachEnvCloudId;
+exports.mergeCloudEnvSets = mergeCloudEnvSets;
+exports.listLocalAliases = listLocalAliases;
+exports.saveLocalAlias = saveLocalAlias;
+exports.deleteLocalAlias = deleteLocalAlias;
+exports.aliasesNeedingPush = aliasesNeedingPush;
+exports.attachAliasCloudId = attachAliasCloudId;
+exports.localCollectionCounts = localCollectionCounts;
+/**
+ * Free local collections under ~/.recall/ (separate files).
+ * Soft caps + size limits prevent vault abuse; cloud sync still requires Pro/Team
+ * and server-side plan gates.
+ */
+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.LOCAL_SOFT_CAPS = {
+    commands: 500,
+    groups: 50,
+    templates: 50,
+    snippets: 50,
+    envSets: 50,
+    aliases: 100,
+};
+exports.LOCAL_SIZE_LIMITS = {
+    commandChars: 10_000,
+    templateChars: 10_000,
+    snippetContentChars: 100_000,
+    envVarsJsonChars: 50_000,
+    nameChars: 200,
+    aliasChars: 64,
+};
+class LocalVaultLimitError extends Error {
+    kind;
+    limit;
+    current;
+    constructor(kind, limit, current) {
+        super(`Local ${kind} limit reached (${current}/${limit}). Delete some or upgrade to Pro to sync a subset.`);
+        this.kind = kind;
+        this.limit = limit;
+        this.current = current;
+        this.name = 'LocalVaultLimitError';
+    }
+}
+exports.LocalVaultLimitError = LocalVaultLimitError;
+class LocalVaultSizeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LocalVaultSizeError';
+    }
+}
+exports.LocalVaultSizeError = LocalVaultSizeError;
+function nowIso() {
+    return new Date().toISOString();
+}
+function ensureDir() {
+    node_fs_1.default.mkdirSync(VAULT_DIR, { recursive: true });
+}
+function collectionPath(file) {
+    return node_path_1.default.join(VAULT_DIR, file);
+}
+function readCollection(file) {
+    const p = collectionPath(file);
+    try {
+        if (!node_fs_1.default.existsSync(p)) {
+            return { version: 1, updatedAt: nowIso(), syncedAt: null, items: [] };
+        }
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(p, 'utf-8'));
+        const items = Array.isArray(parsed.items)
+            ? parsed.items
+            : Array.isArray(parsed.groups)
+                ? parsed.groups
+                : Array.isArray(parsed.templates)
+                    ? parsed.templates
+                    : Array.isArray(parsed.snippets)
+                        ? parsed.snippets
+                        : Array.isArray(parsed.envSets)
+                            ? parsed.envSets
+                            : Array.isArray(parsed.aliases)
+                                ? parsed.aliases
+                                : [];
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : nowIso(),
+            syncedAt: typeof parsed.syncedAt === 'string' ? parsed.syncedAt : null,
+            items,
+        };
+    }
+    catch {
+        return { version: 1, updatedAt: nowIso(), syncedAt: null, items: [] };
+    }
+}
+function writeCollection(file, key, items, syncedAt) {
+    ensureDir();
+    const payload = {
+        version: 1,
+        updatedAt: nowIso(),
+        syncedAt: syncedAt ?? null,
+        [key]: items,
+        items, // dual-write for forward readers
+    };
+    node_fs_1.default.writeFileSync(collectionPath(file), JSON.stringify(payload, null, 2), { mode: 0o600 });
+}
+function assertUnderCap(kind, current) {
+    const limit = exports.LOCAL_SOFT_CAPS[kind];
+    if (current >= limit) {
+        throw new LocalVaultLimitError(kind, limit, current);
+    }
+}
+function assertName(name) {
+    const t = name.trim();
+    if (!t)
+        throw new LocalVaultSizeError('Name is required');
+    if (t.length > exports.LOCAL_SIZE_LIMITS.nameChars) {
+        throw new LocalVaultSizeError(`Name too long (max ${exports.LOCAL_SIZE_LIMITS.nameChars})`);
+    }
+    return t;
+}
+function listLocalGroups() {
+    return readCollection('groups.json').items.sort((a, b) => a.name.localeCompare(b.name));
+}
+function saveLocalGroup(name) {
+    const n = assertName(name);
+    const file = readCollection('groups.json');
+    const existing = file.items.find((g) => g.name.toLowerCase() === n.toLowerCase());
+    if (existing) {
+        existing.name = n;
+        existing.updatedAt = nowIso();
+        writeCollection('groups.json', 'groups', file.items, file.syncedAt);
+        return existing;
+    }
+    assertUnderCap('groups', file.items.length);
+    const row = {
+        id: (0, node_crypto_1.randomUUID)(),
+        name: n,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+    };
+    file.items.push(row);
+    writeCollection('groups.json', 'groups', file.items, file.syncedAt);
+    return row;
+}
+function deleteLocalGroup(id) {
+    const file = readCollection('groups.json');
+    const idx = file.items.findIndex((g) => g.id === id);
+    if (idx < 0)
+        return undefined;
+    const [removed] = file.items.splice(idx, 1);
+    writeCollection('groups.json', 'groups', file.items, file.syncedAt);
+    return removed;
+}
+function renameLocalGroup(id, name) {
+    const n = assertName(name);
+    const file = readCollection('groups.json');
+    const row = file.items.find((g) => g.id === id);
+    if (!row)
+        return undefined;
+    row.name = n;
+    row.updatedAt = nowIso();
+    writeCollection('groups.json', 'groups', file.items, file.syncedAt);
+    return row;
+}
+function groupsNeedingPush() {
+    return listLocalGroups().filter((g) => !g.cloudId);
+}
+function attachGroupCloudId(localId, cloudId) {
+    const file = readCollection('groups.json');
+    const row = file.items.find((g) => g.id === localId);
+    if (!row)
+        return;
+    row.cloudId = cloudId;
+    row.updatedAt = nowIso();
+    writeCollection('groups.json', 'groups', file.items, file.syncedAt);
+}
+function mergeCloudGroups(cloud) {
+    const file = readCollection('groups.json');
+    const stamp = nowIso();
+    let added = 0;
+    let updated = 0;
+    for (const c of cloud) {
+        const byCloud = file.items.find((g) => g.cloudId === c.id);
+        const byName = file.items.find((g) => g.name.toLowerCase() === c.name.toLowerCase());
+        const target = byCloud ?? byName;
+        if (target) {
+            target.cloudId = c.id;
+            target.name = c.name;
+            target.updatedAt = stamp;
+            updated++;
+        }
+        else {
+            file.items.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                cloudId: c.id,
+                name: c.name,
+                createdAt: c.createdAt ?? stamp,
+                updatedAt: stamp,
+            });
+            added++;
+        }
+    }
+    writeCollection('groups.json', 'groups', file.items, stamp);
+    return { added, updated };
+}
+function listLocalTemplates() {
+    return readCollection('templates.json').items.sort((a, b) => a.name.localeCompare(b.name));
+}
+function saveLocalTemplate(input) {
+    const name = assertName(input.name);
+    const template = input.template.trim();
+    if (!template)
+        throw new LocalVaultSizeError('Template body is required');
+    if (template.length > exports.LOCAL_SIZE_LIMITS.templateChars) {
+        throw new LocalVaultSizeError(`Template too long (max ${exports.LOCAL_SIZE_LIMITS.templateChars})`);
+    }
+    const file = readCollection('templates.json');
+    const existing = file.items.find((t) => t.name.toLowerCase() === name.toLowerCase());
+    if (existing) {
+        existing.template = template;
+        existing.tags = input.tags?.length ? input.tags : undefined;
+        existing.updatedAt = nowIso();
+        writeCollection('templates.json', 'templates', file.items, file.syncedAt);
+        return existing;
+    }
+    assertUnderCap('templates', file.items.length);
+    const row = {
+        id: (0, node_crypto_1.randomUUID)(),
+        name,
+        template,
+        tags: input.tags?.length ? input.tags : undefined,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+    };
+    file.items.push(row);
+    writeCollection('templates.json', 'templates', file.items, file.syncedAt);
+    return row;
+}
+function updateLocalTemplate(id, patch) {
+    const file = readCollection('templates.json');
+    const row = file.items.find((t) => t.id === id);
+    if (!row)
+        return undefined;
+    if (patch.name !== undefined)
+        row.name = assertName(patch.name);
+    if (patch.template !== undefined) {
+        const t = patch.template.trim();
+        if (t.length > exports.LOCAL_SIZE_LIMITS.templateChars) {
+            throw new LocalVaultSizeError(`Template too long (max ${exports.LOCAL_SIZE_LIMITS.templateChars})`);
+        }
+        row.template = t;
+    }
+    if (patch.tags !== undefined)
+        row.tags = patch.tags.length ? patch.tags : undefined;
+    row.updatedAt = nowIso();
+    writeCollection('templates.json', 'templates', file.items, file.syncedAt);
+    return row;
+}
+function deleteLocalTemplate(id) {
+    const file = readCollection('templates.json');
+    const idx = file.items.findIndex((t) => t.id === id);
+    if (idx < 0)
+        return undefined;
+    const [removed] = file.items.splice(idx, 1);
+    writeCollection('templates.json', 'templates', file.items, file.syncedAt);
+    return removed;
+}
+function templatesNeedingPush() {
+    return listLocalTemplates().filter((t) => !t.cloudId);
+}
+function attachTemplateCloudId(localId, cloudId) {
+    const file = readCollection('templates.json');
+    const row = file.items.find((t) => t.id === localId);
+    if (!row)
+        return;
+    row.cloudId = cloudId;
+    row.updatedAt = nowIso();
+    writeCollection('templates.json', 'templates', file.items, file.syncedAt);
+}
+function mergeCloudTemplates(cloud) {
+    const file = readCollection('templates.json');
+    const stamp = nowIso();
+    let added = 0;
+    let updated = 0;
+    for (const c of cloud) {
+        const byCloud = file.items.find((t) => t.cloudId === c.id);
+        const byName = file.items.find((t) => t.name.toLowerCase() === c.name.toLowerCase());
+        const target = byCloud ?? byName;
+        if (target) {
+            target.cloudId = c.id;
+            target.name = c.name;
+            target.template = c.template;
+            target.tags = c.tags?.length ? c.tags : undefined;
+            target.updatedAt = stamp;
+            updated++;
+        }
+        else {
+            file.items.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                cloudId: c.id,
+                name: c.name,
+                template: c.template,
+                tags: c.tags?.length ? c.tags : undefined,
+                createdAt: stamp,
+                updatedAt: stamp,
+            });
+            added++;
+        }
+    }
+    writeCollection('templates.json', 'templates', file.items, stamp);
+    return { added, updated };
+}
+function listLocalSnippets() {
+    return readCollection('snippets.json').items.sort((a, b) => a.name.localeCompare(b.name));
+}
+function saveLocalSnippet(input) {
+    const name = assertName(input.name);
+    if (input.content.length > exports.LOCAL_SIZE_LIMITS.snippetContentChars) {
+        throw new LocalVaultSizeError(`Snippet too large (max ${exports.LOCAL_SIZE_LIMITS.snippetContentChars} chars)`);
+    }
+    const file = readCollection('snippets.json');
+    const existing = file.items.find((s) => s.name.toLowerCase() === name.toLowerCase());
+    if (existing) {
+        existing.content = input.content;
+        existing.tags = input.tags?.length ? input.tags : undefined;
+        existing.updatedAt = nowIso();
+        writeCollection('snippets.json', 'snippets', file.items, file.syncedAt);
+        return existing;
+    }
+    assertUnderCap('snippets', file.items.length);
+    const row = {
+        id: (0, node_crypto_1.randomUUID)(),
+        name,
+        content: input.content,
+        tags: input.tags?.length ? input.tags : undefined,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+    };
+    file.items.push(row);
+    writeCollection('snippets.json', 'snippets', file.items, file.syncedAt);
+    return row;
+}
+function updateLocalSnippet(id, patch) {
+    const file = readCollection('snippets.json');
+    const row = file.items.find((s) => s.id === id);
+    if (!row)
+        return undefined;
+    if (patch.name !== undefined)
+        row.name = assertName(patch.name);
+    if (patch.content !== undefined) {
+        if (patch.content.length > exports.LOCAL_SIZE_LIMITS.snippetContentChars) {
+            throw new LocalVaultSizeError(`Snippet too large (max ${exports.LOCAL_SIZE_LIMITS.snippetContentChars} chars)`);
+        }
+        row.content = patch.content;
+    }
+    if (patch.tags !== undefined)
+        row.tags = patch.tags.length ? patch.tags : undefined;
+    row.updatedAt = nowIso();
+    writeCollection('snippets.json', 'snippets', file.items, file.syncedAt);
+    return row;
+}
+function deleteLocalSnippet(id) {
+    const file = readCollection('snippets.json');
+    const idx = file.items.findIndex((s) => s.id === id);
+    if (idx < 0)
+        return undefined;
+    const [removed] = file.items.splice(idx, 1);
+    writeCollection('snippets.json', 'snippets', file.items, file.syncedAt);
+    return removed;
+}
+function snippetsNeedingPush() {
+    return listLocalSnippets().filter((s) => !s.cloudId);
+}
+function attachSnippetCloudId(localId, cloudId) {
+    const file = readCollection('snippets.json');
+    const row = file.items.find((s) => s.id === localId);
+    if (!row)
+        return;
+    row.cloudId = cloudId;
+    row.updatedAt = nowIso();
+    writeCollection('snippets.json', 'snippets', file.items, file.syncedAt);
+}
+function mergeCloudSnippets(cloud) {
+    const file = readCollection('snippets.json');
+    const stamp = nowIso();
+    let added = 0;
+    let updated = 0;
+    for (const c of cloud) {
+        const byCloud = file.items.find((s) => s.cloudId === c.id);
+        const byName = file.items.find((s) => s.name.toLowerCase() === c.name.toLowerCase());
+        const target = byCloud ?? byName;
+        if (target) {
+            target.cloudId = c.id;
+            target.name = c.name;
+            target.content = c.content;
+            target.tags = c.tags?.length ? c.tags : undefined;
+            target.updatedAt = stamp;
+            updated++;
+        }
+        else {
+            file.items.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                cloudId: c.id,
+                name: c.name,
+                content: c.content,
+                tags: c.tags?.length ? c.tags : undefined,
+                createdAt: stamp,
+                updatedAt: stamp,
+            });
+            added++;
+        }
+    }
+    writeCollection('snippets.json', 'snippets', file.items, stamp);
+    return { added, updated };
+}
+function listLocalEnvSets() {
+    return readCollection('env.json').items.sort((a, b) => a.name.localeCompare(b.name));
+}
+function saveLocalEnvSet(input) {
+    const name = assertName(input.name);
+    const json = JSON.stringify(input.vars);
+    if (json.length > exports.LOCAL_SIZE_LIMITS.envVarsJsonChars) {
+        throw new LocalVaultSizeError(`Env set too large (max ${exports.LOCAL_SIZE_LIMITS.envVarsJsonChars} chars)`);
+    }
+    // Reject obvious secret-stuffing patterns in keys only (values stay local; sync still Pro-gated)
+    for (const k of Object.keys(input.vars)) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) {
+            throw new LocalVaultSizeError(`Invalid env var name: ${k}`);
+        }
+    }
+    const file = readCollection('env.json');
+    const existing = file.items.find((e) => e.name.toLowerCase() === name.toLowerCase());
+    if (existing) {
+        existing.vars = input.vars;
+        existing.updatedAt = nowIso();
+        writeCollection('env.json', 'envSets', file.items, file.syncedAt);
+        return existing;
+    }
+    assertUnderCap('envSets', file.items.length);
+    const row = {
+        id: (0, node_crypto_1.randomUUID)(),
+        name,
+        vars: input.vars,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+    };
+    file.items.push(row);
+    writeCollection('env.json', 'envSets', file.items, file.syncedAt);
+    return row;
+}
+function deleteLocalEnvSet(id) {
+    const file = readCollection('env.json');
+    const idx = file.items.findIndex((e) => e.id === id);
+    if (idx < 0)
+        return undefined;
+    const [removed] = file.items.splice(idx, 1);
+    writeCollection('env.json', 'envSets', file.items, file.syncedAt);
+    return removed;
+}
+function updateLocalEnvSet(id, patch) {
+    const file = readCollection('env.json');
+    const row = file.items.find((e) => e.id === id);
+    if (!row)
+        return undefined;
+    if (patch.name !== undefined)
+        row.name = assertName(patch.name);
+    if (patch.vars !== undefined) {
+        const json = JSON.stringify(patch.vars);
+        if (json.length > exports.LOCAL_SIZE_LIMITS.envVarsJsonChars) {
+            throw new LocalVaultSizeError(`Env set too large (max ${exports.LOCAL_SIZE_LIMITS.envVarsJsonChars} chars)`);
+        }
+        row.vars = patch.vars;
+    }
+    row.updatedAt = nowIso();
+    writeCollection('env.json', 'envSets', file.items, file.syncedAt);
+    return row;
+}
+function envSetsNeedingPush() {
+    return listLocalEnvSets().filter((e) => !e.cloudId);
+}
+function attachEnvCloudId(localId, cloudId) {
+    const file = readCollection('env.json');
+    const row = file.items.find((e) => e.id === localId);
+    if (!row)
+        return;
+    row.cloudId = cloudId;
+    row.updatedAt = nowIso();
+    writeCollection('env.json', 'envSets', file.items, file.syncedAt);
+}
+function mergeCloudEnvSets(cloud) {
+    const file = readCollection('env.json');
+    const stamp = nowIso();
+    let added = 0;
+    let updated = 0;
+    for (const c of cloud) {
+        if (!c.vars)
+            continue; // list endpoint may omit vars — skip incomplete
+        const byCloud = c.id ? file.items.find((e) => e.cloudId === c.id) : undefined;
+        const byName = file.items.find((e) => e.name.toLowerCase() === c.name.toLowerCase());
+        const target = byCloud ?? byName;
+        if (target) {
+            if (c.id)
+                target.cloudId = c.id;
+            target.name = c.name;
+            target.vars = c.vars;
+            target.updatedAt = stamp;
+            updated++;
+        }
+        else {
+            file.items.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                cloudId: c.id,
+                name: c.name,
+                vars: c.vars,
+                createdAt: stamp,
+                updatedAt: stamp,
+            });
+            added++;
+        }
+    }
+    writeCollection('env.json', 'envSets', file.items, stamp);
+    return { added, updated };
+}
+function listLocalAliases() {
+    return readCollection('aliases.json').items.sort((a, b) => a.alias.localeCompare(b.alias));
+}
+function saveLocalAlias(input) {
+    const alias = input.alias.trim();
+    if (!alias || /\s/.test(alias)) {
+        throw new LocalVaultSizeError('Alias must be a single token without spaces');
+    }
+    if (alias.length > exports.LOCAL_SIZE_LIMITS.aliasChars) {
+        throw new LocalVaultSizeError(`Alias too long (max ${exports.LOCAL_SIZE_LIMITS.aliasChars})`);
+    }
+    const file = readCollection('aliases.json');
+    const existing = file.items.find((a) => a.alias.toLowerCase() === alias.toLowerCase());
+    if (existing) {
+        existing.localCommandId = input.localCommandId;
+        existing.updatedAt = nowIso();
+        writeCollection('aliases.json', 'aliases', file.items, file.syncedAt);
+        return existing;
+    }
+    assertUnderCap('aliases', file.items.length);
+    const row = {
+        id: (0, node_crypto_1.randomUUID)(),
+        alias,
+        localCommandId: input.localCommandId,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+    };
+    file.items.push(row);
+    writeCollection('aliases.json', 'aliases', file.items, file.syncedAt);
+    return row;
+}
+function deleteLocalAlias(id) {
+    const file = readCollection('aliases.json');
+    const idx = file.items.findIndex((a) => a.id === id);
+    if (idx < 0)
+        return undefined;
+    const [removed] = file.items.splice(idx, 1);
+    writeCollection('aliases.json', 'aliases', file.items, file.syncedAt);
+    return removed;
+}
+function aliasesNeedingPush() {
+    return listLocalAliases().filter((a) => !a.cloudId);
+}
+function attachAliasCloudId(localId, cloudId) {
+    const file = readCollection('aliases.json');
+    const row = file.items.find((a) => a.id === localId);
+    if (!row)
+        return;
+    row.cloudId = cloudId;
+    row.updatedAt = nowIso();
+    writeCollection('aliases.json', 'aliases', file.items, file.syncedAt);
+}
+function localCollectionCounts() {
+    return {
+        commands: 0, // filled by caller from commands vault
+        groups: listLocalGroups().length,
+        templates: listLocalTemplates().length,
+        snippets: listLocalSnippets().length,
+        envSets: listLocalEnvSets().length,
+        aliases: listLocalAliases().length,
+    };
+}

package/dist/lib/local-vault.js

@@ -20,6 +20,7 @@ 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 local_collections_1 = require("./local-collections");
 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() {
@@ -127,13 +128,19 @@ function findLocalByName(name) {
     return readVault().commands.find((c) => c.name?.toLowerCase() === needle);
 }
 function saveLocalCommand(input) {
+    const command = input.command.trim();
+    if (!command)
+        throw new local_collections_1.LocalVaultSizeError('Command is required');
+    if (command.length > local_collections_1.LOCAL_SIZE_LIMITS.commandChars) {
+        throw new local_collections_1.LocalVaultSizeError(`Command too long (max ${local_collections_1.LOCAL_SIZE_LIMITS.commandChars})`);
+    }
     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.command = command;
             existing.tags = input.tags?.length ? input.tags : undefined;
             existing.updatedAt = stamp;
             // Local edit invalidates cloud link until next push maps again
@@ -141,9 +148,12 @@ function saveLocalCommand(input) {
             return existing;
         }
     }
+    if (vault.commands.length >= local_collections_1.LOCAL_SOFT_CAPS.commands) {
+        throw new local_collections_1.LocalVaultLimitError('commands', local_collections_1.LOCAL_SOFT_CAPS.commands, vault.commands.length);
+    }
     const saved = {
         id: (0, node_crypto_1.randomUUID)(),
-        command: input.command,
+        command,
         name,
         tags: input.tags?.length ? input.tags : undefined,
         createdAt: stamp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkitvault/recall",
-  "version": "1.2.10",
+  "version": "1.2.11",
   "description": "recall CLI — personal command vault for your terminal (local-first)",
   "keywords": [
     "cli",
@@ -19,11 +19,11 @@
   "license": "MIT",
   "homepage": "https://recall.devkitvault.com",
   "bugs": {
-    "url": "https://github.com/devkitvault/recall-cli/issues"
+    "url": "https://github.com/devkitvaultorg/recall-cli/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/devkitvault/recall-cli.git"
+    "url": "git+https://github.com/devkitvaultorg/recall-cli.git"
   },
     "bin": {
         "recall": "dist/index.js",