@andespindola/brainlink 1.6.3 → 1.6.4

package/dist/application/vault-bundle.js

@@ -0,0 +1,72 @@
+// Multi-vault bundle (`.blbundle`): a single gzip-compressed envelope carrying one
+// snapshot per vault, built on the reusable single-vault snapshot helpers. Exports
+// all known vaults (or a chosen subset) into one movable file; import restores every
+// bundled vault back to its recorded path or a chosen target, preserving conflicts.
+import { readFile, writeFile } from 'node:fs/promises';
+import { gzipSync, gunzipSync } from 'node:zlib';
+import { basename, resolve } from 'node:path';
+import { buildSnapshotEnvelope, applySnapshotEnvelope } from './vault-snapshot.js';
+const bundleVersion = 1;
+const bundleKind = 'brainlink-vault-bundle';
+const dedupePaths = (vaultPaths) => {
+    const seen = new Set();
+    const paths = [];
+    for (const vaultPath of vaultPaths) {
+        if (seen.has(vaultPath)) {
+            continue;
+        }
+        seen.add(vaultPath);
+        paths.push(vaultPath);
+    }
+    return paths;
+};
+const parseBundle = (raw) => {
+    const envelope = JSON.parse(gunzipSync(raw).toString('utf8'));
+    if (!envelope || envelope.kind !== bundleKind || envelope.version !== bundleVersion || !Array.isArray(envelope.vaults)) {
+        throw new Error('Unrecognized .blbundle format.');
+    }
+    return envelope;
+};
+export const exportVaultsBundle = async (vaultPaths, outputFile) => {
+    const uniquePaths = dedupePaths(vaultPaths);
+    const vaults = await Promise.all(uniquePaths.map(async (vaultPath) => {
+        const vault = resolve(vaultPath);
+        return { vault, name: basename(vault), snapshot: await buildSnapshotEnvelope(vaultPath) };
+    }));
+    const envelope = {
+        version: bundleVersion,
+        kind: bundleKind,
+        createdAt: new Date().toISOString(),
+        vaults
+    };
+    const packed = gzipSync(Buffer.from(JSON.stringify(envelope), 'utf8'), { level: 9 });
+    await writeFile(outputFile, packed, { mode: 0o600 });
+    const fileCount = vaults.reduce((total, entry) => total + entry.snapshot.files.length, 0);
+    return { file: outputFile, vaultCount: vaults.length, fileCount, bytes: packed.byteLength };
+};
+export const listBundleVaults = async (bundleFile) => {
+    const envelope = parseBundle(await readFile(bundleFile));
+    return envelope.vaults.map((entry) => ({
+        name: entry.name,
+        vault: entry.vault,
+        fileCount: entry.snapshot.files.length
+    }));
+};
+export const importVaultsBundle = async (bundleFile, options = {}) => {
+    const envelope = parseBundle(await readFile(bundleFile));
+    const selected = options.only
+        ? envelope.vaults.filter((entry) => entry.name === options.only || entry.vault === options.only)
+        : envelope.vaults;
+    if (options.only && selected.length === 0) {
+        throw new Error(`No vault "${options.only}" in bundle.`);
+    }
+    if (options.targetVault && selected.length > 1) {
+        throw new Error('targetVault requires selecting a single vault via only.');
+    }
+    const vaults = await Promise.all(selected.map(async (entry) => {
+        const target = options.targetVault ?? entry.vault;
+        const result = await applySnapshotEnvelope(entry.snapshot, target, { skipIndex: options.skipIndex });
+        return { name: entry.name, vault: target, imported: result.imported, conflicted: result.conflicted };
+    }));
+    return { vaults };
+};

package/dist/application/vault-snapshot.js

@@ -19,7 +19,7 @@ const conflictName = (path) => {
     const base = extension ? path.slice(0, -extension.length) : path;
     return `${base}.conflict-${stamp}${extension}`;
 };
-export const exportVaultSnapshot = async (vaultPath, outputFile) => {
+export const buildSnapshotEnvelope = async (vaultPath) => {
     const root = await ensureVault(vaultPath);
     const markdownFiles = (await listVaultFiles(root)).filter(isMarkdown);
     const entries = await Promise.all(markdownFiles.map(async (absolutePath) => {
@@ -30,15 +30,18 @@ export const exportVaultSnapshot = async (vaultPath, outputFile) => {
             file: { path, contentB64: content.toString('base64') }
         };
     }));
-    const envelope = {
+    return {
         version: snapshotVersion,
         createdAt: new Date().toISOString(),
         manifest: entries.map((entry) => entry.manifest),
         files: entries.map((entry) => entry.file)
     };
+};
+export const exportVaultSnapshot = async (vaultPath, outputFile) => {
+    const envelope = await buildSnapshotEnvelope(vaultPath);
     const packed = gzipSync(Buffer.from(JSON.stringify(envelope), 'utf8'), { level: 9 });
     await writeFile(outputFile, packed, { mode: 0o600 });
-    return { file: outputFile, fileCount: entries.length, bytes: packed.byteLength };
+    return { file: outputFile, fileCount: envelope.files.length, bytes: packed.byteLength };
 };
 const parseEnvelope = (raw) => {
     const envelope = JSON.parse(gunzipSync(raw).toString('utf8'));
@@ -47,9 +50,8 @@ const parseEnvelope = (raw) => {
     }
     return envelope;
 };
-export const importVaultSnapshot = async (snapshotFile, vaultPath, options = {}) => {
+export const applySnapshotEnvelope = async (envelope, vaultPath, options = {}) => {
     const root = await ensureVault(vaultPath);
-    const envelope = parseEnvelope(await readFile(snapshotFile));
     const manifestByPath = new Map(envelope.manifest.map((entry) => [entry.path, entry]));
     let imported = 0;
     let conflicted = 0;
@@ -85,3 +87,7 @@ export const importVaultSnapshot = async (snapshotFile, vaultPath, options = {})
     const index = !options.skipIndex && imported + conflicted > 0 ? await indexVault(root) : undefined;
     return { imported, conflicted, index };
 };
+export const importVaultSnapshot = async (snapshotFile, vaultPath, options = {}) => {
+    const envelope = parseEnvelope(await readFile(snapshotFile));
+    return applySnapshotEnvelope(envelope, vaultPath, options);
+};

package/dist/cli/commands/vault-sync-commands.js

@@ -1,6 +1,8 @@
 import { cloneVault, commitVault, initVaultGit, pullVault, pushVault, restoreVault, vaultGitStatus, vaultHistory } from '../../application/vault-git.js';
 import { provisionVaultRepo } from '../../application/provision-vault.js';
 import { exportVaultSnapshot, importVaultSnapshot } from '../../application/vault-snapshot.js';
+import { exportVaultsBundle, importVaultsBundle, listBundleVaults } from '../../application/vault-bundle.js';
+import { getKnownVaults } from '../../infrastructure/config.js';
 import { print, resolveOptions } from '../runtime.js';
 export const registerVaultSyncCommands = (program) => {
     program
@@ -113,25 +115,48 @@ export const registerVaultSyncCommands = (program) => {
     });
     program
         .command('vault-export')
-        .requiredOption('-o, --output <file>', 'output .blvault file')
+        .option('-o, --output <file>', 'output file (.blvault for one vault, .blbundle with --all)')
         .option('--vault <vault>', 'vault directory')
+        .option('--all', 'export every known vault (config vault + allowedVaults) into a single .blbundle')
         .option('--json', 'print machine-readable JSON')
-        .description('export the vault Markdown to a portable .blvault snapshot')
+        .description('export vault Markdown to a portable snapshot: one vault (.blvault) or all vaults (--all, .blbundle)')
         .action(async (options) => {
-        const { vault } = await resolveOptions(options);
+        const { config, vault } = await resolveOptions(options);
+        if (options.all) {
+            const vaults = getKnownVaults(config);
+            const result = await exportVaultsBundle(vaults, options.output ?? 'vaults.blbundle');
+            print(options.json, result, () => `Exported ${result.vaultCount} vaults (${result.fileCount} files) to ${result.file} (${result.bytes} bytes).`);
+            return;
+        }
         const result = await exportVaultSnapshot(vault, options.output ?? 'vault.blvault');
         print(options.json, result, () => `Exported ${result.fileCount} files to ${result.file} (${result.bytes} bytes).`);
     });
     program
         .command('vault-import')
-        .argument('<file>', 'input .blvault file')
-        .option('--vault <vault>', 'vault directory')
+        .argument('<file>', 'input .blvault snapshot or .blbundle')
+        .option('--vault <vault>', 'target vault directory (single snapshot, or the target for --only)')
+        .option('--only <vault>', 'when importing a bundle, restore only this vault (by name or recorded path)')
         .option('--no-index', 'skip reindexing after import')
         .option('--json', 'print machine-readable JSON')
-        .description('import a .blvault snapshot into the vault and reindex')
+        .description('import a .blvault snapshot into a vault, or a .blbundle (all vaults, or one via --only)')
         .action(async (file, options) => {
+        const skipIndex = options.index === false;
+        // Auto-detect a bundle so a single command handles both formats. --only is
+        // bundle-only, so it forces the bundle path.
+        const bundleEntries = await listBundleVaults(file).catch(() => null);
+        if (bundleEntries !== null || options.only !== undefined) {
+            const result = await importVaultsBundle(file, {
+                only: options.only,
+                targetVault: options.only !== undefined ? options.vault : undefined,
+                skipIndex
+            });
+            print(options.json, result, () => result.vaults
+                .map((entry) => `${entry.name} → ${entry.vault}: imported ${entry.imported} (${entry.conflicted} conflicts)`)
+                .join('\n'));
+            return;
+        }
         const { vault } = await resolveOptions(options);
-        const result = await importVaultSnapshot(file, vault, { skipIndex: options.index === false });
+        const result = await importVaultSnapshot(file, vault, { skipIndex });
         print(options.json, result, () => `Imported ${result.imported} files (${result.conflicted} conflicts)${result.index ? `; reindexed ${result.index.documentCount} docs` : ''}.`);
     });
 };

package/dist/infrastructure/config.js

@@ -248,6 +248,19 @@ const sanitizeConfig = (value) => ({
     defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode),
     agentProfiles: sanitizeAgentProfiles(value.agentProfiles)
 });
+export const getKnownVaults = (config) => {
+    const seen = new Set();
+    const vaults = [];
+    for (const vault of [config.vault, ...config.allowedVaults]) {
+        const trimmed = vault.trim();
+        if (trimmed.length === 0 || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        vaults.push(trimmed);
+    }
+    return vaults;
+};
 export const resolveAgentRuntimeDefaults = (config, agent) => {
     const normalizedAgent = agent?.trim().length ? sanitizeAgentId(agent) : undefined;
     const profile = (normalizedAgent ? config.agentProfiles[normalizedAgent] : undefined) ?? config.agentProfiles['*'];

package/dist/mcp/server.js

@@ -1,5 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { addNoteInputSchema, addFileInputSchema, addFileTool, addNoteTool, addNotesInputSchema, addNotesTool, deleteNoteInputSchema, deleteNoteTool, deleteNotesInputSchema, deleteNotesTool, volatileAddInputSchema, volatileAddTool, volatileClearInputSchema, volatileClearTool, dedupeInputSchema, dedupeResolveInputSchema, dedupeResolveTool, dedupeTool, brokenLinksInputSchema, brokenLinksTool, bootstrapInputSchema, bootstrapTool, canonicalizeContextLinksInputSchema, canonicalizeContextLinksTool, contextInputSchema, contextPacksInputSchema, contextPacksTool, contextTool, doctorActionsInputSchema, doctorActionsTool, graphContextsInputSchema, graphContextsTool, graphInputSchema, graphTool, explainInputSchema, explainTool, indexInputSchema, indexTool, inboxAddInputSchema, inboxAddTool, inboxListInputSchema, inboxListTool, inboxProcessInputSchema, inboxProcessTool, orphansInputSchema, orphansTool, policyInputSchema, policyTool, projectInitInputSchema, projectInitTool, recommendationsInputSchema, recommendationsTool, rememberInputSchema, rememberTool, repairLinksInputSchema, repairLinksTool, searchInputSchema, searchTool, similarNotesInputSchema, similarNotesTool, sessionCloseInputSchema, sessionCloseTool, statsInputSchema, statsTool, suggestLinksInputSchema, suggestLinksTool, syncInputSchema, syncTool, validateInputSchema, validateTool, vaultCommitInputSchema, vaultCommitTool, vaultExportInputSchema, vaultExportTool, vaultHistoryInputSchema, vaultHistoryTool, vaultImportInputSchema, vaultImportTool, vaultInitInputSchema, vaultInitTool, vaultMergeAgentsInputSchema, vaultMergeAgentsTool, vaultProvisionInputSchema, vaultProvisionTool, vaultPullInputSchema, vaultPullTool, vaultRestoreInputSchema, vaultRestoreTool, vaultStatusInputSchema, vaultStatusTool, versionInputSchema, versionTool } from './tools.js';
+import { addNoteInputSchema, addFileInputSchema, addFileTool, addNoteTool, addNotesInputSchema, addNotesTool, deleteNoteInputSchema, deleteNoteTool, deleteNotesInputSchema, deleteNotesTool, volatileAddInputSchema, volatileAddTool, volatileClearInputSchema, volatileClearTool, dedupeInputSchema, dedupeResolveInputSchema, dedupeResolveTool, dedupeTool, brokenLinksInputSchema, brokenLinksTool, bootstrapInputSchema, bootstrapTool, canonicalizeContextLinksInputSchema, canonicalizeContextLinksTool, contextInputSchema, contextPacksInputSchema, contextPacksTool, contextTool, doctorActionsInputSchema, doctorActionsTool, graphContextsInputSchema, graphContextsTool, graphInputSchema, graphTool, explainInputSchema, explainTool, indexInputSchema, indexTool, inboxAddInputSchema, inboxAddTool, inboxListInputSchema, inboxListTool, inboxProcessInputSchema, inboxProcessTool, orphansInputSchema, orphansTool, policyInputSchema, policyTool, projectInitInputSchema, projectInitTool, recommendationsInputSchema, recommendationsTool, rememberInputSchema, rememberTool, repairLinksInputSchema, repairLinksTool, searchInputSchema, searchTool, similarNotesInputSchema, similarNotesTool, sessionCloseInputSchema, sessionCloseTool, statsInputSchema, statsTool, suggestLinksInputSchema, suggestLinksTool, syncInputSchema, syncTool, validateInputSchema, validateTool, vaultBundleListInputSchema, vaultBundleListTool, vaultCommitInputSchema, vaultCommitTool, vaultExportBundleInputSchema, vaultExportBundleTool, vaultExportInputSchema, vaultExportTool, vaultHistoryInputSchema, vaultHistoryTool, vaultImportBundleInputSchema, vaultImportBundleTool, vaultImportInputSchema, vaultImportTool, vaultInitInputSchema, vaultInitTool, vaultMergeAgentsInputSchema, vaultMergeAgentsTool, vaultProvisionInputSchema, vaultProvisionTool, vaultPullInputSchema, vaultPullTool, vaultRestoreInputSchema, vaultRestoreTool, vaultStatusInputSchema, vaultStatusTool, versionInputSchema, versionTool } from './tools.js';
 import { getRuntimeVersion } from './runtime.js';
 import { brainlinkServerInstructions } from './server-instructions.js';
 import { guardToolHandler } from './tool-guard.js';
@@ -206,6 +206,21 @@ export const createBrainlinkMcpServer = () => {
         description: 'Import a .blvault snapshot into the vault and reindex. Checksums are verified; divergent local files are preserved as *.conflict-<ts>.md instead of being overwritten.',
         inputSchema: vaultImportInputSchema
     }, vaultImportTool);
+    server.registerTool('brainlink_vault_export_bundle', {
+        title: 'Export All Vaults (bundle)',
+        description: 'Write a portable .blbundle containing every known vault (config vault + allowedVaults). Each vault is a gzip-free snapshot envelope inside one gzipped bundle; the derived index is not included.',
+        inputSchema: vaultExportBundleInputSchema
+    }, vaultExportBundleTool);
+    server.registerTool('brainlink_vault_bundle_list', {
+        title: 'List Vaults in a Bundle',
+        description: 'Inspect a .blbundle and list the vaults it contains (name, recorded path, file count) without importing anything.',
+        inputSchema: vaultBundleListInputSchema
+    }, vaultBundleListTool);
+    server.registerTool('brainlink_vault_import_bundle', {
+        title: 'Import Vaults from a Bundle',
+        description: 'Import a .blbundle: restore every vault to its recorded path, or a single one via "only" (optionally into "targetVault"). Checksums are verified; divergent local files are preserved as *.conflict-<ts>.md.',
+        inputSchema: vaultImportBundleInputSchema
+    }, vaultImportBundleTool);
     server.registerTool('brainlink_graph', {
         title: 'Read Brainlink Graph',
         description: 'Read indexed graph nodes and wiki-link edges. Edges include weight and priority fields so agents can rank importance and priority.',

package/dist/mcp/tools/vault-tools.js

@@ -2,7 +2,9 @@ import { z } from 'zod';
 import { commitVault, initVaultGit, pullVault, pushVault, restoreVault, vaultGitStatus, vaultHistory } from '../../application/vault-git.js';
 import { provisionVaultRepo } from '../../application/provision-vault.js';
 import { exportVaultSnapshot, importVaultSnapshot } from '../../application/vault-snapshot.js';
+import { exportVaultsBundle, importVaultsBundle, listBundleVaults } from '../../application/vault-bundle.js';
 import { mergeAgentNamespace } from '../../application/merge-agent-namespace.js';
+import { getKnownVaults, loadBrainlinkConfig } from '../../infrastructure/config.js';
 import { jsonResult, optionalPositiveInteger, resolveExecutionContext, vaultInput } from './shared.js';
 export const vaultStatusInputSchema = { ...vaultInput };
 export const vaultInitInputSchema = {
@@ -38,6 +40,19 @@ export const vaultImportInputSchema = {
     snapshotFile: z.string().min(1).describe('Path to a .blvault snapshot to import. Divergent local files are preserved as *.conflict-<ts>.md.'),
     skipIndex: z.boolean().optional().default(false).describe('Skip the automatic reindex after importing Markdown.')
 };
+export const vaultExportBundleInputSchema = {
+    ...vaultInput,
+    outputFile: z.string().min(1).describe('Path to write the portable .blbundle to (contains every known vault).')
+};
+export const vaultBundleListInputSchema = {
+    bundleFile: z.string().min(1).describe('Path to a .blbundle to inspect.')
+};
+export const vaultImportBundleInputSchema = {
+    bundleFile: z.string().min(1).describe('Path to a .blbundle to import. Divergent local files are preserved as *.conflict-<ts>.md.'),
+    only: z.string().min(1).optional().describe('Restore only this vault from the bundle (by name or recorded path). Omit to restore every vault.'),
+    targetVault: z.string().min(1).optional().describe('Target directory for the restored vault (only valid with "only"). Defaults to the recorded path.'),
+    skipIndex: z.boolean().optional().default(false).describe('Skip the automatic reindex after importing Markdown.')
+};
 export const vaultProvisionInputSchema = {
     ...vaultInput,
     name: z.string().min(1).optional().describe('Repository name to create. Defaults to brainlink-vault.'),
@@ -163,6 +178,38 @@ export const vaultImportTool = async (input) => {
         return failure(context.vault, error);
     }
 };
+export const vaultExportBundleTool = async (input) => {
+    const context = await resolveExecutionContext(input);
+    try {
+        const config = await loadBrainlinkConfig();
+        const result = await exportVaultsBundle(getKnownVaults(config), input.outputFile);
+        return jsonResult({ ok: true, ...result });
+    }
+    catch (error) {
+        return failure(context.vault, error);
+    }
+};
+export const vaultBundleListTool = async (input) => {
+    try {
+        return jsonResult({ ok: true, bundleFile: input.bundleFile, vaults: await listBundleVaults(input.bundleFile) });
+    }
+    catch (error) {
+        return jsonResult({ ok: false, bundleFile: input.bundleFile, error: error instanceof Error ? error.message : String(error) });
+    }
+};
+export const vaultImportBundleTool = async (input) => {
+    try {
+        const result = await importVaultsBundle(input.bundleFile, {
+            only: input.only,
+            targetVault: input.targetVault,
+            skipIndex: input.skipIndex === true
+        });
+        return jsonResult({ ok: true, ...result });
+    }
+    catch (error) {
+        return jsonResult({ ok: false, bundleFile: input.bundleFile, error: error instanceof Error ? error.message : String(error) });
+    }
+};
 export const vaultMergeAgentsTool = async (input) => {
     const context = await resolveExecutionContext(input);
     try {

package/dist/mcp/tools.js

@@ -1,4 +1,4 @@
 export { brokenLinksInputSchema, brokenLinksTool, contextInputSchema, contextPacksInputSchema, contextPacksTool, contextTool, doctorActionsInputSchema, doctorActionsTool, explainInputSchema, explainTool, graphContextsInputSchema, graphContextsTool, graphInputSchema, graphTool, orphansInputSchema, orphansTool, recommendationsInputSchema, recommendationsTool, searchInputSchema, searchTool, similarNotesInputSchema, similarNotesTool, statsInputSchema, statsTool, suggestLinksInputSchema, suggestLinksTool, validateInputSchema, validateTool, versionInputSchema, versionTool } from './tools/read-tools.js';
 export { addFileInputSchema, addFileTool, addNoteInputSchema, addNoteTool, addNotesInputSchema, addNotesTool, deleteNoteInputSchema, deleteNoteTool, deleteNotesInputSchema, deleteNotesTool, inboxAddInputSchema, inboxAddTool, inboxListInputSchema, inboxListTool, inboxProcessInputSchema, inboxProcessTool, rememberInputSchema, rememberTool, volatileAddInputSchema, volatileAddTool, volatileClearInputSchema, volatileClearTool } from './tools/write-tools.js';
 export { bootstrapInputSchema, bootstrapTool, canonicalizeContextLinksInputSchema, canonicalizeContextLinksTool, dedupeInputSchema, dedupeResolveInputSchema, dedupeResolveTool, dedupeTool, indexInputSchema, indexTool, policyInputSchema, policyTool, projectInitInputSchema, projectInitTool, repairLinksInputSchema, repairLinksTool, sessionCloseInputSchema, sessionCloseTool, syncInputSchema, syncTool } from './tools/maintenance-tools.js';
-export { vaultCommitInputSchema, vaultCommitTool, vaultExportInputSchema, vaultExportTool, vaultHistoryInputSchema, vaultHistoryTool, vaultImportInputSchema, vaultImportTool, vaultInitInputSchema, vaultInitTool, vaultMergeAgentsInputSchema, vaultMergeAgentsTool, vaultProvisionInputSchema, vaultProvisionTool, vaultPullInputSchema, vaultPullTool, vaultRestoreInputSchema, vaultRestoreTool, vaultStatusInputSchema, vaultStatusTool } from './tools/vault-tools.js';
+export { vaultBundleListInputSchema, vaultBundleListTool, vaultCommitInputSchema, vaultCommitTool, vaultExportBundleInputSchema, vaultExportBundleTool, vaultExportInputSchema, vaultExportTool, vaultHistoryInputSchema, vaultHistoryTool, vaultImportBundleInputSchema, vaultImportBundleTool, vaultImportInputSchema, vaultImportTool, vaultInitInputSchema, vaultInitTool, vaultMergeAgentsInputSchema, vaultMergeAgentsTool, vaultProvisionInputSchema, vaultProvisionTool, vaultPullInputSchema, vaultPullTool, vaultRestoreInputSchema, vaultRestoreTool, vaultStatusInputSchema, vaultStatusTool } from './tools/vault-tools.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",