@devkitvault/recall 1.2.9 → 1.2.11

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,