dsh-vault 0.3.0 → 0.5.0

package/lib/index.js

@@ -53,7 +53,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import Schema from '@deepseek-ai/schemastery';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { openVault, defaultVaultPath } from "./store.js";
 import { totp } from "./totp.js";
@@ -71,12 +72,26 @@ export const Config = Schema.object({
         Schema.const('auto'),
     ]),
     autoCapture: Schema.boolean(),
+    lockTimeoutSeconds: Schema.number(),
+    exportPasswordEnv: Schema.string(),
 });
 export async function apply(ctx, config) {
     const masterPassword = resolveMasterPassword(config);
     const WRITE_TOOLS = new Set(['vault_add', 'vault_update', 'vault_delete']);
+    const lockTimeoutSeconds = config.lockTimeoutSeconds ?? 0;
     /** Shared access policy; resolved once, mutated by the UI via setAccessMode. */
     const policy = await sharedAccessPolicy(config);
+    /** Audit events: other plugins / session logging can subscribe. Payload is
+     * non-secret (tool name + entry id/title only). */
+    const emitAudit = (kind, tool, entryId, title) => {
+        try {
+            ;
+            ctx.emit(`vault/${kind}`, { tool, entryId, title, at: Date.now() });
+        }
+        catch {
+            // A throwing listener must never break the vault operation.
+        }
+    };
     /** Reject mutations when the vault is in readonly mode. */
     function assertWritable(action) {
         if (policy.mode === 'readonly') {
@@ -90,19 +105,56 @@ export async function apply(ctx, config) {
      * call `next()` (waterfall event).
      */
     ctx.on('tools/pre-execute', async (exec, next) => {
-        if (policy.mode === 'ask' && exec?.name !== undefined && WRITE_TOOLS.has(exec.name)) {
+        if (exec?.name === undefined)
+            return next();
+        if (policy.mode === 'ask' && WRITE_TOOLS.has(exec.name)) {
             return { kind: 'ask', reason: `dsh-vault: ${exec.name} requires your confirmation in "ask" (prompt-before-write) mode` };
         }
+        // High-sensitivity reads: in ask mode, reading a `high` entry's secrets
+        // (vault_get by id) also requires confirmation.
+        if (policy.mode === 'ask' && exec.name === 'vault_get') {
+            const id = exec.arguments?.id;
+            if (id !== undefined) {
+                try {
+                    const store = await ensureStore();
+                    const entry = store.get(id);
+                    if (entry?.sensitivity === 'high') {
+                        return { kind: 'ask', reason: `dsh-vault: reading high-sensitivity entry "${entry.title}" requires your confirmation` };
+                    }
+                }
+                catch {
+                    // If the vault is locked etc., let the tool itself report it.
+                }
+            }
+        }
         return next();
     });
     /** Ensure the shared store is open (lazily on first use, so a missing
      * master password fails at the first tool call with a clear message). */
     async function ensureStore() {
-        return sharedVaultStore(masterPassword, config);
+        const store = await sharedVaultStore(masterPassword, config);
+        // Install the auto-lock policy once per store instance.
+        if (lockTimeoutSeconds > 0)
+            store.setAutoLock(lockTimeoutSeconds * 1000);
+        return store;
+    }
+    /** Guard every tool: enforce auto-lock (relock when idle, refuse when
+     * locked) and touch the activity timestamp. */
+    async function guardStore() {
+        const store = await ensureStore();
+        if (store.expired) {
+            store.lock();
+            throw new Error('vault is locked (idle timeout) — call vault_unlock to re-open it');
+        }
+        if (store.isLocked) {
+            throw new Error('vault is locked — call vault_unlock to re-open it');
+        }
+        store.touch();
+        return store;
     }
-    /** Read a full entry (with secrets) by id. */
+    /** Read a full entry (with secrets) by id (respects locking). */
     async function readEntry(id) {
-        const s = await ensureStore();
+        const s = await guardStore();
         return s.get(id);
     }
     // System prompt guidance: tells the model how the vault works, what the
@@ -186,7 +238,7 @@ export async function apply(ctx, config) {
             assertWritable('vault_add');
             if (!args.title.trim())
                 throw new Error('vault_add: title must not be empty');
-            const s = await ensureStore();
+            const s = await guardStore();
             const entry = await s.add({
                 title: args.title.trim(),
                 ...(args.kind !== undefined ? { kind: args.kind } : {}),
@@ -208,6 +260,7 @@ export async function apply(ctx, config) {
                 ...(args.tags !== undefined ? { tags: args.tags } : {}),
                 ...(args.fields !== undefined ? { fields: args.fields } : {}),
             });
+            emitAudit('write', 'vault_add', entry.id, entry.title);
             return { id: entry.id, title: entry.title, message: 'added credential entry' };
         },
     }));
@@ -233,6 +286,7 @@ export async function apply(ctx, config) {
             const entry = await readEntry(args.id);
             if (!entry)
                 return { found: false };
+            emitAudit('read', 'vault_get', entry.id, entry.title);
             return { found: true, entry: stripTimestamps(entry) };
         },
     }));
@@ -267,7 +321,7 @@ export async function apply(ctx, config) {
                 }],
         },
         async execute(args) {
-            const s = await ensureStore();
+            const s = await guardStore();
             const limit = validateLimit(args.limit, 'vault_search');
             const results = s.search(args.query, limit);
             return { results, total: results.length };
@@ -321,7 +375,7 @@ export async function apply(ctx, config) {
         },
         async execute(args) {
             assertWritable('vault_update');
-            const s = await ensureStore();
+            const s = await guardStore();
             const patch = {};
             for (const key of [
                 'title', 'kind', 'username', 'email', 'phone', 'password', 'host', 'port', 'privateKey',
@@ -336,6 +390,7 @@ export async function apply(ctx, config) {
             const updated = await s.update(args.id, patch);
             if (!updated)
                 return { found: false };
+            emitAudit('write', 'vault_update', updated.id, updated.title);
             return { found: true, entry: toSummaryJson(updated) };
         },
     }));
@@ -358,8 +413,10 @@ export async function apply(ctx, config) {
         },
         async execute(args) {
             assertWritable('vault_delete');
-            const s = await ensureStore();
+            const s = await guardStore();
             const deleted = await s.delete(args.id);
+            if (deleted)
+                emitAudit('write', 'vault_delete', args.id);
             return { deleted, message: deleted ? 'entry deleted' : 'entry not found' };
         },
     }));
@@ -448,6 +505,372 @@ export async function apply(ctx, config) {
             return { password, length: password.length };
         },
     }));
+    // ── vault_lock / vault_unlock: explicit lock & unlock ──────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_lock',
+        description: 'Lock the vault immediately: wipe the derived key from memory so every '
+            + 'subsequent read/write requires vault_unlock. Use when leaving the machine.',
+        parameters: {},
+        output: { schema: { type: 'object', additionalProperties: false, properties: { locked: { type: 'boolean', required: true } } }, render: (_a, v) => [{ type: 'text', text: v.locked ? 'vault locked' : 'vault not unlocked' }] },
+        async execute() {
+            const s = await ensureStore();
+            const was = s.isLocked;
+            s.lock();
+            return { locked: !was };
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: 'vault_unlock',
+        description: 'Unlock the vault with the master password (the deployment owns the password; '
+            + 'the model never supplies it). Needed after an explicit vault_lock or an auto-lock idle timeout.',
+        parameters: {},
+        output: { schema: { type: 'object', additionalProperties: false, properties: { unlocked: { type: 'boolean', required: true } } }, render: (_a, v) => [{ type: 'text', text: v.unlocked ? 'vault unlocked' : 'vault already unlocked' }] },
+        async execute() {
+            const s = await ensureStore();
+            if (!s.isLocked)
+                return { unlocked: false };
+            await s.unlock();
+            return { unlocked: true };
+        },
+    }));
+    // ── vault_totp_uri: build an otpauth:// provisioning URI ────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_totp_uri',
+        description: 'Build an otpauth://totp/ provisioning URI for a stored otpSecret (or a bare secret), '
+            + 'so the user can scan it into an authenticator app. Returns the URI string.',
+        parameters: {
+            id: { type: 'string', description: 'Vault entry id whose otpSecret to use. Provide exactly one of id or secret.' },
+            secret: { type: 'string', description: 'Bare Base32 secret. Provide exactly one of id or secret.' },
+            label: { type: 'string', description: 'Account label in the URI (default: entry title or "dsh-vault").' },
+            issuer: { type: 'string', description: 'Issuer name (default: "dsh-vault").' },
+        },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { uri: { type: 'string', required: true } } }, render: (_a, v) => [{ type: 'text', text: v.uri }] },
+        async execute(args) {
+            if ((args.id === undefined) === (args.secret === undefined)) {
+                throw new Error('vault_totp_uri: provide exactly one of id or secret');
+            }
+            let secret;
+            let label = args.label;
+            if (args.id !== undefined) {
+                const entry = await readEntry(args.id);
+                if (!entry?.otpSecret)
+                    throw new Error(`vault_totp_uri: entry ${args.id} has no otpSecret`);
+                secret = entry.otpSecret;
+                label = label ?? entry.title;
+            }
+            else {
+                secret = args.secret;
+                label = label ?? 'dsh-vault';
+            }
+            const issuer = args.issuer ?? 'dsh-vault';
+            const encodedLabel = encodeURIComponent(`${issuer}:${label ?? ''}`);
+            const params = new URLSearchParams({ secret, issuer, algorithm: 'SHA1', digits: '6', period: '30' });
+            return { uri: `otpauth://totp/${encodedLabel}?${params.toString()}` };
+        },
+    }));
+    // ── vault_rotation: expiry / rotation report ───────────────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_rotation',
+        description: 'Report credentials that are expired, due for rotation (rotationDays elapsed), '
+            + 'or expiring within 7 days. Returns summaries with a due state — never secrets.',
+        parameters: {},
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { entries: { type: 'array', required: true, items: { type: 'json' } } } },
+            render: (_a, v) => [{ type: 'text', text: v.entries.length === 0 ? 'no rotation items' : JSON.stringify(v.entries) }],
+        },
+        async execute() {
+            const s = await guardStore();
+            return { entries: s.rotationReport() };
+        },
+    }));
+    // ── vault_health: weak / reused credential scan ────────────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_health',
+        description: 'Scan the vault for weak passwords (shorter than 12 chars) and credentials reused '
+            + 'across entries. Returns non-secret findings (entry summaries grouped by the reused value).',
+        parameters: {},
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { weak: { type: 'array', required: true, items: { type: 'json' } }, reused: { type: 'array', required: true, items: { type: 'json' } } } },
+            render: (_a, v) => [{ type: 'text', text: `weak: ${v.weak.length}, reused groups: ${v.reused.length}` }],
+        },
+        async execute() {
+            const s = await guardStore();
+            return s.health();
+        },
+    }));
+    // ── vault_restore / vault_purge: trash management ──────────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_restore',
+        description: 'Restore a soft-deleted entry from the vault trash back into the active set.',
+        parameters: { id: { type: 'string', required: true, description: 'The trashed entry id.' } },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { restored: { type: 'boolean', required: true } } }, render: (_a, v) => [{ type: 'text', text: v.restored ? 'entry restored' : 'entry not found in trash' }] },
+        async execute(args) {
+            assertWritable('vault_restore');
+            const s = await guardStore();
+            return { restored: await s.restore(args.id) };
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: 'vault_purge',
+        description: 'Permanently delete an entry (active or trashed). Cannot be undone — prefer vault_delete '
+            + '(soft delete) unless the entry must be removed from disk.',
+        parameters: { id: { type: 'string', required: true, description: 'The entry id to purge.' } },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { purged: { type: 'boolean', required: true } } }, render: (_a, v) => [{ type: 'text', text: v.purged ? 'entry purged' : 'entry not found' }] },
+        async execute(args) {
+            assertWritable('vault_purge');
+            const s = await guardStore();
+            return { purged: await s.purge(args.id) };
+        },
+    }));
+    // ── vault_export / vault_import: portable encrypted transfer ───────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_export',
+        description: 'Export the entire vault (including trash) as a single encrypted document under a '
+            + 'separate export password (from the exportPasswordEnv config). Use for backup or migration; '
+            + 'the export can be re-imported with vault_import. Never pass the password as an argument.',
+        parameters: {},
+        output: { schema: { type: 'object', additionalProperties: false, properties: { exported: { type: 'boolean', required: true }, note: { type: 'string', required: true } } }, render: (_a, v) => [{ type: 'text', text: v.note }] },
+        async execute() {
+            const exportPassword = resolveExportPassword(config);
+            const s = await guardStore();
+            const blob = await s.exportEncrypted(exportPassword);
+            const file = join(dirname(resolveVaultPath(config)), `vault-export-${Date.now()}.json`);
+            await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+            await writeFile(file, blob, { mode: 0o600 });
+            return { exported: true, note: `vault exported to ${file}` };
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: 'vault_import',
+        description: 'Import a previously exported vault document (see vault_export), merging entries by '
+            + 'id. Pass the document path; the export password comes from the exportPasswordEnv config.',
+        parameters: { path: { type: 'string', required: true, description: 'Absolute path of the exported vault JSON file.' } },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { imported: { type: 'integer', required: true } } }, render: (_a, v) => [{ type: 'text', text: `imported ${v.imported} entries` }] },
+        async execute(args) {
+            assertWritable('vault_import');
+            const exportPassword = resolveExportPassword(config);
+            const s = await guardStore();
+            const blob = await readFile(args.path, 'utf8');
+            const count = await s.importEncrypted(blob, exportPassword);
+            return { imported: count };
+        },
+    }));
+    // ── vault_fill: find the credential that fits a target ─────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_fill',
+        description: 'Find the vault entry that fits a target (host/URL/username/title) and return the '
+            + 'ready-to-use credentials (secrets included, as the caller needs them for the actual login). '
+            + 'Use instead of vault_search+vault_get when you know what you are connecting to.',
+        parameters: {
+            target: { type: 'string', required: true, description: 'Host, URL, username, or title to match.' },
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean', required: true }, entry: { type: 'json' } } },
+            render: (_a, v) => [{ type: 'text', text: v.found ? `matched: ${v.entry?.title ?? 'entry'}` : 'no matching entry' }],
+        },
+        async execute(args) {
+            const s = await guardStore();
+            const needle = args.target.trim().toLowerCase();
+            for (const entry of s.list()) {
+                const haystack = [entry.title, entry.host, entry.url, entry.username, entry.email].filter(Boolean).join(' ').toLowerCase();
+                if (needle.length > 0 && haystack.includes(needle)) {
+                    return { found: true, entry: stripTimestamps(entry) };
+                }
+            }
+            return { found: false };
+        },
+    }));
+    // ── vault_env: environment-variable export ─────────────────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_env',
+        description: 'Render entries flagged for environment export (tags contain "env") as KEY=VALUE lines '
+            + 'suitable for .env or export statements. Keys derive from the title + field name; values are the '
+            + 'secrets. Returns the lines so the caller can write them to a file (user-authorized).',
+        parameters: {},
+        output: { schema: { type: 'object', additionalProperties: false, properties: { lines: { type: 'array', required: true, items: { type: 'string' } } } }, render: (_a, v) => [{ type: 'text', text: v.lines.join('\n') }] },
+        async execute() {
+            const s = await guardStore();
+            const lines = [];
+            const keyOf = (title, field) => title.toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') + '_' + field.toUpperCase();
+            for (const entry of s.list()) {
+                if (!(entry.tags ?? []).includes('env'))
+                    continue;
+                for (const [field, value] of Object.entries(entry)) {
+                    if (typeof value !== 'string' || value.length === 0)
+                        continue;
+                    if (['id', 'title', 'kind', 'sensitivity', 'host', 'url', 'notes', 'createdAt', 'updatedAt', 'deletedAt'].includes(field))
+                        continue;
+                    if (['username', 'email', 'phone', 'port', 'tags'].includes(field))
+                        continue;
+                    lines.push(`${keyOf(entry.title, field)}=${value}`);
+                }
+            }
+            return { lines };
+        },
+    }));
+    // ── vault_templates: field templates by kind ───────────────────────────────
+    const TEMPLATES = {
+        login: { username: 'account username', email: 'account email', password: 'account password' },
+        ssh: { host: 'server host', port: 'port (e.g. 22)', username: 'login user', password: 'password or passphrase', privateKey: 'PEM private key' },
+        'api-key': { apiKey: 'the API key', url: 'API base URL', username: 'owner/account (optional)' },
+        oauth: { accessToken: 'access token', refreshToken: 'refresh token', expiresAt: 'expiry epoch millis', clientId: 'client id (via fields)' },
+        secret: { secret: 'the shared secret', notes: 'what it is for' },
+        custom: { fields: 'arbitrary key/value pairs' },
+    };
+    ctx.tools.register(defineTool({
+        name: 'vault_templates',
+        description: 'Return the recommended fields for a credential kind, so vault_add can be called with '
+            + 'the right field names (e.g. kind ssh → host/port/username/password/privateKey).',
+        parameters: { kind: { type: 'string', description: 'Entry kind; default login.', enum: ['login', 'ssh', 'api-key', 'secret', 'oauth', 'custom'] } },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { kind: { type: 'string', required: true }, fields: { type: 'json', required: true } } }, render: (_a, v) => [{ type: 'text', text: JSON.stringify(v.fields) }] },
+        async execute(args) {
+            const kind = args.kind ?? 'login';
+            return { kind, fields: TEMPLATES[kind] ?? TEMPLATES.login };
+        },
+    }));
+    // ── vault_strength: zero-dependency password strength estimation ────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_strength',
+        description: 'Estimate the strength of a password with a zero-dependency heuristic '
+            + '(length, character-class diversity, common-pattern penalties). Returns a score 0–100 '
+            + 'and a verdict: weak / fair / strong / very strong. Use before choosing or storing a password.',
+        parameters: { password: { type: 'string', required: true, description: 'The password to evaluate.' } },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { score: { type: 'integer', required: true }, verdict: { type: 'string', required: true }, feedback: { type: 'string', required: true } } },
+            render: (_a, v) => [{ type: 'text', text: `${v.verdict} (${v.score}/100) — ${v.feedback}` }],
+        },
+        async execute(args) {
+            const r = estimateStrength(args.password);
+            return r;
+        },
+    }));
+    // ── vault_import_csv: bulk import from a CSV file ───────────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_import_csv',
+        description: 'Bulk-import credentials from a CSV file. Expected columns (header row): '
+            + 'title,username,password,url,email,phone,host,port,apiKey,secret,notes,tags,kind. '
+            + 'Unknown columns become custom fields. Returns how many entries were added and skipped.',
+        parameters: {
+            path: { type: 'string', required: true, description: 'Absolute path of the CSV file.' },
+            delimiter: { type: 'string', description: 'CSV delimiter (default ",").' },
+            overwrite: { type: 'boolean', description: 'Replace entries with the same title (default false).' },
+        },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { added: { type: 'integer', required: true }, skipped: { type: 'integer', required: true } } }, render: (_a, v) => [{ type: 'text', text: `imported ${v.added}, skipped ${v.skipped}` }] },
+        async execute(args) {
+            assertWritable('vault_import_csv');
+            const s = await guardStore();
+            const raw = await readFile(args.path, 'utf8');
+            const rows = parseCsv(raw, args.delimiter ?? ',');
+            if (rows.length === 0)
+                return { added: 0, skipped: 0 };
+            const headers = rows[0].map(h => h.trim());
+            const known = new Set(['title', 'username', 'password', 'url', 'email', 'phone', 'host', 'port',
+                'apiKey', 'secret', 'notes', 'tags', 'kind', 'sensitivity']);
+            let added = 0;
+            let skipped = 0;
+            const now = Date.now();
+            for (let i = 1; i < rows.length; i++) {
+                const row = rows[i];
+                if (row.length === 1 && row[0].trim() === '')
+                    continue; // blank line
+                const record = { title: row[0] ?? '' };
+                const fields = {};
+                for (let c = 1; c < headers.length && c < row.length; c++) {
+                    const header = headers[c];
+                    const value = row[c] ?? '';
+                    if (value === '')
+                        continue;
+                    if (known.has(header)) {
+                        if (header === 'tags')
+                            record[header] = value.split(/[;,]/).map(t => t.trim()).filter(Boolean);
+                        else
+                            record[header] = value;
+                    }
+                    else {
+                        fields[header] = value;
+                    }
+                }
+                if (record.title === '') {
+                    skipped++;
+                    continue;
+                }
+                if (Object.keys(fields).length > 0)
+                    record.fields = fields;
+                const title = record.title;
+                if (s.list().some(e => e.title === title) && !args.overwrite) {
+                    skipped++;
+                    continue;
+                }
+                const entry = {
+                    id: randomUUID(),
+                    title,
+                    createdAt: now,
+                    updatedAt: now,
+                    ...pickDefinedFromRecord(record),
+                };
+                s.insertDirect(entry);
+                added++;
+            }
+            await s.persist();
+            return { added, skipped };
+        },
+    }));
+    // ── vault_switch / vault_list: multi-vault navigation ───────────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_list',
+        description: 'List available vaults in the vault directory (one .json file per vault, excluding '
+            + 'access/meta/export files). Marks the currently active one.',
+        parameters: {},
+        output: { schema: { type: 'object', additionalProperties: false, properties: { vaults: { type: 'array', required: true, items: { type: 'json' } } } }, render: (_a, v) => [{ type: 'text', text: JSON.stringify(v.vaults) }] },
+        async execute() {
+            const dir = dirname(resolveVaultPath(config));
+            const names = [];
+            try {
+                const entries = await readdir(dir);
+                for (const entry of entries) {
+                    const m = /^(.*)\.json$/.exec(entry);
+                    if (!m)
+                        continue;
+                    if (['access', 'meta'].includes(m[1]) || m[1].startsWith('vault-export-'))
+                        continue;
+                    names.push(m[1]);
+                }
+            }
+            catch { /* dir may not exist yet */ }
+            const active = currentVaultName ?? config.name ?? 'default';
+            return { vaults: names.sort().map(name => ({ name, active: name === active })) };
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: 'vault_switch',
+        description: 'Switch the active vault for this session. Future vault_* calls operate on the named '
+            + 'vault (created on first use). Returns the newly active vault name.',
+        parameters: { name: { type: 'string', required: true, description: 'Vault name (e.g. "work" or "personal").' } },
+        output: { schema: { type: 'object', additionalProperties: false, properties: { active: { type: 'string', required: true } } }, render: (_a, v) => [{ type: 'text', text: `switched to vault "${v.active}"` }] },
+        async execute(args) {
+            const name = args.name.trim();
+            if (name.length === 0)
+                throw new Error('vault_switch: name must not be empty');
+            if (!/^[a-zA-Z0-9._-]+$/.test(name))
+                throw new Error('vault_switch: name may contain only letters, digits, . _ -');
+            currentVaultName = name;
+            return { active: name };
+        },
+    }));
+    // ── vault_rekey: upgrade the scrypt KDF parameters in place ────────────────
+    ctx.tools.register(defineTool({
+        name: 'vault_rekey',
+        description: 'Upgrade the vault encryption to fresh scrypt KDF parameters (higher cost) and '
+            + 're-encrypt every entry in place. Safe to run periodically or after raising the vault '
+            + 'cost expectations; the old document is replaced atomically. Returns the new cost parameter n.',
+        parameters: {},
+        output: { schema: { type: 'object', additionalProperties: false, properties: { n: { type: 'integer', required: true } } }, render: (_a, v) => [{ type: 'text', text: `vault re-keyed with scrypt N=${v.n}` }] },
+        async execute() {
+            assertWritable('vault_rekey');
+            const s = await guardStore();
+            return await s.rekey();
+        },
+    }));
     // UI-facing Remote gateway: the browser Settings Vault page talks to these
     // methods through the /api RPC channel (loopback-trusted), bypassing the
     // model-tool layer entirely. Secrets are returned because the UI is the
@@ -472,6 +895,10 @@ let VaultGateway = (() => {
     let _config_decorators;
     let _setAccessMode_decorators;
     let _list_decorators;
+    let _trash_decorators;
+    let _restore_decorators;
+    let _rotation_decorators;
+    let _health_decorators;
     let _get_decorators;
     let _search_decorators;
     let _add_decorators;
@@ -484,6 +911,10 @@ let VaultGateway = (() => {
             _config_decorators = [Remote('config')];
             _setAccessMode_decorators = [Remote('setAccessMode')];
             _list_decorators = [Remote('list')];
+            _trash_decorators = [Remote('trash')];
+            _restore_decorators = [Remote('restore')];
+            _rotation_decorators = [Remote('rotation')];
+            _health_decorators = [Remote('health')];
             _get_decorators = [Remote('get')];
             _search_decorators = [Remote('search')];
             _add_decorators = [Remote('add')];
@@ -493,6 +924,10 @@ let VaultGateway = (() => {
             __esDecorate(this, null, _config_decorators, { kind: "method", name: "config", static: false, private: false, access: { has: obj => "config" in obj, get: obj => obj.config }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setAccessMode_decorators, { kind: "method", name: "setAccessMode", static: false, private: false, access: { has: obj => "setAccessMode" in obj, get: obj => obj.setAccessMode }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _trash_decorators, { kind: "method", name: "trash", static: false, private: false, access: { has: obj => "trash" in obj, get: obj => obj.trash }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _restore_decorators, { kind: "method", name: "restore", static: false, private: false, access: { has: obj => "restore" in obj, get: obj => obj.restore }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rotation_decorators, { kind: "method", name: "rotation", static: false, private: false, access: { has: obj => "rotation" in obj, get: obj => obj.rotation }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _health_decorators, { kind: "method", name: "health", static: false, private: false, access: { has: obj => "health" in obj, get: obj => obj.health }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _search_decorators, { kind: "method", name: "search", static: false, private: false, access: { has: obj => "search" in obj, get: obj => obj.search }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _add_decorators, { kind: "method", name: "add", static: false, private: false, access: { has: obj => "add" in obj, get: obj => obj.add }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -552,6 +987,27 @@ let VaultGateway = (() => {
             const store = await this.ensureStore();
             return { entries: store.list().map(toSummary) };
         }
+        /** List trashed (soft-deleted) entries as non-secret summaries. */
+        async trash() {
+            const store = await this.ensureStore();
+            return { entries: store.listTrash().map(toSummary) };
+        }
+        /** Restore a trashed entry (non-secret summary returned). */
+        async restore(id) {
+            this.assertWritable('restore');
+            const store = await this.ensureStore();
+            return { restored: await store.restore(id) };
+        }
+        /** Rotation/expiry report (no secrets). */
+        async rotation() {
+            const store = await this.ensureStore();
+            return { entries: store.rotationReport() };
+        }
+        /** Health scan findings (no secrets). */
+        async health() {
+            const store = await this.ensureStore();
+            return store.health();
+        }
         /** Read one full entry (including secrets) by id. */
         async get(id) {
             const store = await this.ensureStore();
@@ -622,6 +1078,7 @@ function toSummary(entry) {
     return {
         id: entry.id,
         title: entry.title,
+        ...(entry.sensitivity !== undefined ? { sensitivity: entry.sensitivity } : {}),
         ...(entry.kind !== undefined ? { kind: entry.kind } : {}),
         ...(entry.username !== undefined ? { username: entry.username } : {}),
         ...(entry.email !== undefined ? { email: entry.email } : {}),
@@ -651,6 +1108,18 @@ function resolveMasterPassword(config) {
     }
     throw new Error('dsh-vault: configure masterPassword or masterPasswordEnv to unlock the vault');
 }
+/** Resolve the export/import password from the configured environment
+ * variable, or fail loudly (the model must never pass it as an argument). */
+function resolveExportPassword(config) {
+    if (config.exportPasswordEnv !== undefined) {
+        const fromEnv = process.env[config.exportPasswordEnv];
+        if (fromEnv === undefined || fromEnv.length === 0) {
+            throw new Error(`dsh-vault: environment variable ${config.exportPasswordEnv} is not set (needed for vault_export/import)`);
+        }
+        return fromEnv;
+    }
+    throw new Error('dsh-vault: configure exportPasswordEnv to use vault_export / vault_import');
+}
 /**
  * Shared vault-store instances keyed by resolved path + master password. The
  * model tools and the UI-facing VaultGateway must observe ONE store so writes
@@ -662,11 +1131,17 @@ function resolveMasterPassword(config) {
  */
 const sharedVaultStores = new Map();
 const sharedAccessPolicies = new Map();
+/** Current vault-name override (vault_switch); undefined = use config name. */
+let currentVaultName;
+/** Reset the session vault-switch override (tests). */
+export function resetVaultSwitch() {
+    currentVaultName = undefined;
+}
 /** Resolve the canonical vault file path for a config (path override or name). */
 function resolveVaultPath(config) {
     if (config.path !== undefined)
         return config.path;
-    return defaultVaultPath(config.name);
+    return defaultVaultPath(currentVaultName ?? config.name);
 }
 /** The `<vault dir>/access.json` path holding the persisted access policy. */
 function accessPolicyFile(config) {
@@ -698,6 +1173,40 @@ async function sharedAccessPolicy(config) {
     sharedAccessPolicies.set(path, policy);
     return policy;
 }
+const MAX_ATTEMPTS = 5;
+const LOCKOUT_MS = 5 * 60 * 1000;
+/** `<vault dir>/meta.json` — failed-attempt counter and lockout window. */
+function metaFile(config) {
+    return join(dirname(resolveVaultPath(config)), 'meta.json');
+}
+async function readMeta(config) {
+    try {
+        const raw = await readFile(metaFile(config), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { failedAttempts: 0 };
+    }
+}
+async function writeMeta(config, meta) {
+    const file = metaFile(config);
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    await writeFile(file, JSON.stringify(meta), { mode: 0o600 });
+}
+/** Record one failed unlock: increment the counter, start a lockout when the
+ * threshold is crossed. */
+async function recordFailedAttempt(config) {
+    const meta = await readMeta(config);
+    meta.failedAttempts = (meta.failedAttempts ?? 0) + 1;
+    if (meta.failedAttempts >= MAX_ATTEMPTS) {
+        meta.lockedUntil = Date.now() + LOCKOUT_MS;
+    }
+    await writeMeta(config, meta);
+}
+/** Clear the counter after a successful unlock. */
+async function clearFailedAttempts(config) {
+    await writeMeta(config, { failedAttempts: 0 });
+}
 /**
  * Open (or reuse) the vault store for one deployment configuration. All
  * callers within the process share the same instance for the same path and
@@ -706,22 +1215,34 @@ async function sharedAccessPolicy(config) {
  */
 async function sharedVaultStore(masterPassword, config) {
     const path = resolveVaultPath(config);
+    // Brute-force guard: refuse to even attempt while a lockout window is open.
+    const meta = await readMeta(config);
+    if (meta.lockedUntil !== undefined && Date.now() < meta.lockedUntil) {
+        const minutes = Math.ceil((meta.lockedUntil - Date.now()) / 60000);
+        throw new Error(`vault is temporarily locked after ${MAX_ATTEMPTS} failed password attempts — retry in ~${minutes} min`);
+    }
     // The master password is part of the identity: a different password must
     // open its own store (and fail authentication) rather than reuse a store
     // unlocked with another password.
     const cacheKey = `${path}\0${masterPassword}`;
     const existing = sharedVaultStores.get(cacheKey);
-    if (existing !== undefined)
+    if (existing !== undefined) {
+        // A successful re-open of a cached store clears the failure counter.
+        await clearFailedAttempts(config);
         return existing;
+    }
     const opening = openVault({
         masterPassword,
         path,
-    }).catch((error) => {
-        // A failed open must not poison the cache for later retries.
+    }).catch(async (error) => {
+        // A failed open must not poison the cache for later retries, and counts
+        // toward the brute-force lockout.
         sharedVaultStores.delete(cacheKey);
+        await recordFailedAttempt(config);
         throw error;
     });
     sharedVaultStores.set(cacheKey, opening);
+    await clearFailedAttempts(config);
     return opening;
 }
 /** Validate a model-supplied result limit: a positive integer capped at 100. */
@@ -739,6 +1260,113 @@ function toSummaryJson(entry) {
 }
 /** Strip timestamps from an entry for model-visible output (keeps secrets
  * when the caller asked for the full entry via vault_get). */
+/** Minimal RFC-4180-ish CSV parser: handles quoted fields with embedded
+ * delimiters/newlines and escaped double quotes. Returns rows of fields. */
+function parseCsv(input, delimiter = ',') {
+    const rows = [];
+    let row = [];
+    let field = '';
+    let inQuotes = false;
+    let i = 0;
+    const pushField = () => { row.push(field); field = ''; };
+    const pushRow = () => { pushField(); rows.push(row); row = []; };
+    while (i < input.length) {
+        const ch = input[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (input[i + 1] === '"') {
+                    field += '"';
+                    i++;
+                }
+                else
+                    inQuotes = false;
+            }
+            else {
+                field += ch;
+            }
+        }
+        else if (ch === '"') {
+            inQuotes = true;
+        }
+        else if (ch === delimiter) {
+            pushField();
+        }
+        else if (ch === '\n') {
+            pushRow();
+        }
+        else if (ch === '\r') {
+            if (input[i + 1] === '\n')
+                i++;
+            pushRow();
+        }
+        else {
+            field += ch;
+        }
+        i++;
+    }
+    if (field.length > 0 || row.length > 0)
+        pushRow();
+    return rows;
+}
+/** Copy only defined non-empty record fields into a VaultEntry-shaped patch,
+ * skipping the identity fields (title handled separately). */
+function pickDefinedFromRecord(record) {
+    const result = {};
+    const identity = new Set(['id', 'createdAt', 'updatedAt', 'deletedAt']);
+    for (const [key, value] of Object.entries(record)) {
+        if (key === 'title' || identity.has(key))
+            continue;
+        if (value === undefined || value === '')
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/** Zero-dependency password strength estimator: score 0–100 from length,
+ * character-class coverage, and penalties for common weak patterns. */
+function estimateStrength(password) {
+    let score = 0;
+    const length = password.length;
+    // Length is the dominant factor.
+    score += Math.min(45, length * 3);
+    const classes = [
+        /[a-z]/.test(password),
+        /[A-Z]/.test(password),
+        /[0-9]/.test(password),
+        /[^A-Za-z0-9]/.test(password),
+    ].filter(Boolean).length;
+    score += classes * 8;
+    // Diversity bonus for longer unique characters.
+    const unique = new Set(password).size;
+    score += Math.min(15, unique);
+    // Penalties for common weak patterns.
+    let feedback = [];
+    if (length < 8)
+        feedback.push('too short (aim ≥ 12)');
+    if (/^(password|123456|qwerty|letmein|admin|welcome|abc123)$/i.test(password)) {
+        score -= 40;
+        feedback.push('common password');
+    }
+    if (/(.)\1{2,}/.test(password)) {
+        score -= 8;
+        feedback.push('repeated characters');
+    }
+    if (/^\d+$/.test(password)) {
+        score -= 15;
+        feedback.push('digits only');
+    }
+    if (/^[a-z]+$/i.test(password)) {
+        score -= 10;
+        feedback.push('letters only');
+    }
+    if (password.length > 0 && new Set(password).size <= Math.max(3, Math.floor(length / 2)))
+        feedback.push('low diversity');
+    score = Math.max(0, Math.min(100, Math.round(score)));
+    const verdict = score >= 80 ? 'very strong' : score >= 60 ? 'strong' : score >= 40 ? 'fair' : 'weak';
+    return { score, verdict, feedback: feedback.length > 0 ? feedback.join('; ') : 'no obvious weaknesses' };
+}
 function stripTimestamps(entry) {
     const { createdAt, updatedAt, ...rest } = entry;
     return rest;