@andespindola/brainlink 0.1.0-beta.99 → 1.0.1

package/dist/infrastructure/config.js

@@ -10,8 +10,11 @@ export const defaultBrainlinkConfig = {
     allowedVaults: [],
     defaultAgent: undefined,
     autoIndexOnWrite: true,
+    autoCanonicalContextLinks: true,
     defaultSearchLimit: 10,
     defaultContextTokens: 2000,
+    defaultContextStrategy: 'rag',
+    defaultContextCacheTtlMs: 120_000,
     embeddingProvider: 'local',
     defaultSearchMode: 'hybrid',
     chunkSize: 1200,
@@ -40,8 +43,10 @@ const safeCwd = () => {
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const embeddingProviders = new Set(['none', 'local']);
 const searchModes = new Set(['fts', 'semantic', 'hybrid']);
+const contextStrategies = new Set(['rag', 'cag', 'auto']);
 const sanitizeEmbeddingProvider = (value) => typeof value === 'string' && embeddingProviders.has(value) ? value : defaultBrainlinkConfig.embeddingProvider;
 export const sanitizeSearchMode = (value, fallback = defaultBrainlinkConfig.defaultSearchMode) => typeof value === 'string' && searchModes.has(value) ? value : fallback;
+export const sanitizeContextStrategy = (value, fallback = 'rag') => typeof value === 'string' && contextStrategies.has(value) ? value : fallback;
 const sanitizeAllowedVaults = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
 const sanitizePositiveNumber = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
 const sanitizeIntegerInRange = (value, fallback, minimum, maximum) => {
@@ -83,10 +88,20 @@ const sanitizeAgentProfile = (value) => {
     const defaultSearchMode = typeof value.defaultSearchMode === 'string' && searchModes.has(value.defaultSearchMode)
         ? value.defaultSearchMode
         : undefined;
+    const defaultContextStrategy = typeof value.defaultContextStrategy === 'string' && contextStrategies.has(value.defaultContextStrategy)
+        ? value.defaultContextStrategy
+        : undefined;
+    const defaultContextCacheTtlMs = typeof value.defaultContextCacheTtlMs === 'number' &&
+        Number.isFinite(value.defaultContextCacheTtlMs) &&
+        value.defaultContextCacheTtlMs > 0
+        ? Math.floor(value.defaultContextCacheTtlMs)
+        : undefined;
     const profile = {
         ...(defaultSearchLimit ? { defaultSearchLimit } : {}),
         ...(defaultContextTokens ? { defaultContextTokens } : {}),
-        ...(defaultSearchMode ? { defaultSearchMode } : {})
+        ...(defaultSearchMode ? { defaultSearchMode } : {}),
+        ...(defaultContextStrategy ? { defaultContextStrategy } : {}),
+        ...(defaultContextCacheTtlMs ? { defaultContextCacheTtlMs } : {})
     };
     return Object.keys(profile).length > 0 ? profile : null;
 };
@@ -159,12 +174,19 @@ const sanitizeConfig = (value) => ({
         ? sanitizeAgentId(value.defaultAgent)
         : defaultBrainlinkConfig.defaultAgent,
     autoIndexOnWrite: typeof value.autoIndexOnWrite === 'boolean' ? value.autoIndexOnWrite : defaultBrainlinkConfig.autoIndexOnWrite,
+    autoCanonicalContextLinks: typeof value.autoCanonicalContextLinks === 'boolean'
+        ? value.autoCanonicalContextLinks
+        : defaultBrainlinkConfig.autoCanonicalContextLinks,
     defaultSearchLimit: typeof value.defaultSearchLimit === 'number' && value.defaultSearchLimit > 0
         ? value.defaultSearchLimit
         : defaultBrainlinkConfig.defaultSearchLimit,
     defaultContextTokens: typeof value.defaultContextTokens === 'number' && value.defaultContextTokens > 0
         ? value.defaultContextTokens
         : defaultBrainlinkConfig.defaultContextTokens,
+    defaultContextStrategy: sanitizeContextStrategy(value.defaultContextStrategy, defaultBrainlinkConfig.defaultContextStrategy),
+    defaultContextCacheTtlMs: typeof value.defaultContextCacheTtlMs === 'number' && Number.isFinite(value.defaultContextCacheTtlMs) && value.defaultContextCacheTtlMs > 0
+        ? Math.floor(value.defaultContextCacheTtlMs)
+        : defaultBrainlinkConfig.defaultContextCacheTtlMs,
     allowedVaults: [...sanitizeAllowedVaults(value.allowedVaults), ...readAllowedVaultsFromEnv()],
     chunkSize: typeof value.chunkSize === 'number' && value.chunkSize > 0 ? value.chunkSize : defaultBrainlinkConfig.chunkSize,
     searchPack: sanitizeSearchPackConfig(value.searchPack),
@@ -178,15 +200,92 @@ export const resolveAgentRuntimeDefaults = (config, agent) => {
     return {
         defaultSearchLimit: profile?.defaultSearchLimit ?? config.defaultSearchLimit,
         defaultContextTokens: profile?.defaultContextTokens ?? config.defaultContextTokens,
-        defaultSearchMode: profile?.defaultSearchMode ?? config.defaultSearchMode
+        defaultSearchMode: profile?.defaultSearchMode ?? config.defaultSearchMode,
+        defaultContextStrategy: profile?.defaultContextStrategy ?? config.defaultContextStrategy,
+        defaultContextCacheTtlMs: profile?.defaultContextCacheTtlMs ?? config.defaultContextCacheTtlMs
+    };
+};
+const mergeConfigLayers = (layers) => layers.reduce((state, config) => ({
+    ...state,
+    ...config
+}), {});
+export const getVaultConfigSourceDetails = async (cwd = safeCwd()) => {
+    const [globalConfig, localConfig, legacyLocalConfig] = await Promise.all([
+        loadRawConfig('global', cwd),
+        loadRawConfig('local', cwd),
+        loadLegacyLocalRawConfig(cwd)
+    ]);
+    if (typeof legacyLocalConfig.vault === 'string' && legacyLocalConfig.vault.trim().length > 0) {
+        return {
+            source: 'local-legacy',
+            sourcePath: resolve(cwd, '.brainlink.json')
+        };
+    }
+    if (typeof localConfig.vault === 'string' && localConfig.vault.trim().length > 0) {
+        return {
+            source: 'local',
+            sourcePath: getLocalConfigPath(cwd)
+        };
+    }
+    if (typeof globalConfig.vault === 'string' && globalConfig.vault.trim().length > 0) {
+        return {
+            source: 'global',
+            sourcePath: getGlobalConfigPath()
+        };
+    }
+    return {
+        source: 'default',
+        sourcePath: null
     };
 };
 export const loadBrainlinkConfig = async (cwd = safeCwd()) => {
     const globalConfig = await readJsonConfig(getGlobalConfigPath());
     const localConfigs = await Promise.all(configFilenames.map((filename) => readJsonConfig(resolve(cwd, filename))));
-    const merged = [globalConfig, ...localConfigs].reduce((state, config) => ({
-        ...state,
-        ...config
-    }), {});
+    const merged = mergeConfigLayers([globalConfig, ...localConfigs]);
     return sanitizeConfig(merged);
 };
+export const loadBrainlinkConfigWithSource = async (cwd = safeCwd()) => {
+    const globalConfigPath = getGlobalConfigPath();
+    const localConfigPath = getLocalConfigPath(cwd);
+    const legacyLocalConfigPath = resolve(cwd, '.brainlink.json');
+    const [globalConfig, localConfig, legacyLocalConfig] = await Promise.all([
+        readJsonConfig(globalConfigPath),
+        readJsonConfig(localConfigPath),
+        readJsonConfig(legacyLocalConfigPath)
+    ]);
+    const config = sanitizeConfig(mergeConfigLayers([globalConfig, localConfig, legacyLocalConfig]));
+    if (typeof legacyLocalConfig.vault === 'string' && legacyLocalConfig.vault.trim().length > 0) {
+        return {
+            config,
+            vaultSource: {
+                source: 'local-legacy',
+                sourcePath: legacyLocalConfigPath
+            }
+        };
+    }
+    if (typeof localConfig.vault === 'string' && localConfig.vault.trim().length > 0) {
+        return {
+            config,
+            vaultSource: {
+                source: 'local',
+                sourcePath: localConfigPath
+            }
+        };
+    }
+    if (typeof globalConfig.vault === 'string' && globalConfig.vault.trim().length > 0) {
+        return {
+            config,
+            vaultSource: {
+                source: 'global',
+                sourcePath: globalConfigPath
+            }
+        };
+    }
+    return {
+        config,
+        vaultSource: {
+            source: 'default',
+            sourcePath: null
+        }
+    };
+};

package/dist/infrastructure/context-packs.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+const normalizePackKey = (key) => ({
+    query: key.query.trim().toLowerCase(),
+    limit: key.limit,
+    maxTokens: key.maxTokens,
+    agentId: key.agentId?.trim().toLowerCase() || undefined,
+    mode: key.mode
+});
+export const contextPacksDirectory = (vaultPath) => join(vaultPath, '.brainlink', 'context-packs');
+export const contextPackPath = (vaultPath, key) => {
+    const digest = createHash('sha256').update(JSON.stringify(normalizePackKey(key))).digest('hex');
+    return join(contextPacksDirectory(vaultPath), `${digest}.json`);
+};
+const isStoredContextPack = (value) => {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return candidate.version === 1 && typeof candidate.dataSignature === 'string' && Boolean(candidate.context);
+};
+const readStoredContextPack = async (path) => {
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return isStoredContextPack(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const toContextPackSummary = async (path, dataSignature) => {
+    const [info, stored] = await Promise.all([
+        stat(path),
+        readStoredContextPack(path)
+    ]);
+    const stale = !stored || (typeof dataSignature === 'string' && stored.dataSignature !== dataSignature);
+    return {
+        path,
+        filename: basename(path),
+        createdAt: stored?.createdAt ?? null,
+        dataSignature: stored?.dataSignature ?? null,
+        key: stored?.key ?? null,
+        sizeBytes: info.size,
+        stale
+    };
+};
+export const listContextPacks = async (vaultPath, dataSignature) => {
+    const directory = contextPacksDirectory(vaultPath);
+    try {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const paths = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+            .map((entry) => join(directory, entry.name));
+        const summaries = await Promise.all(paths.map((path) => toContextPackSummary(path, dataSignature)));
+        return summaries.sort((left, right) => (right.createdAt ?? '').localeCompare(left.createdAt ?? '') || left.filename.localeCompare(right.filename));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+};
+export const clearContextPacks = async (vaultPath, options = {}) => {
+    const packs = await listContextPacks(vaultPath, options.dataSignature);
+    const removed = options.staleOnly ? packs.filter((pack) => pack.stale) : packs;
+    const kept = options.staleOnly ? packs.filter((pack) => !pack.stale) : [];
+    await Promise.all(removed.map((pack) => rm(pack.path, { force: true })));
+    return { removed, kept };
+};
+export const readContextPack = async (vaultPath, key, dataSignature) => {
+    const path = contextPackPath(vaultPath, key);
+    try {
+        const parsed = await readStoredContextPack(path);
+        if (!parsed) {
+            return { status: 'stale', path };
+        }
+        if (parsed.dataSignature !== dataSignature) {
+            return { status: 'stale', path };
+        }
+        return {
+            status: 'hit',
+            path,
+            context: {
+                ...parsed.context,
+                strategy: 'cag',
+                cache: {
+                    storage: 'context-pack',
+                    status: 'hit',
+                    dataSignature,
+                    path
+                }
+            }
+        };
+    }
+    catch {
+        return { status: 'miss', path };
+    }
+};
+export const writeContextPack = async (vaultPath, key, dataSignature, context) => {
+    const path = contextPackPath(vaultPath, key);
+    const stored = {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        dataSignature,
+        key: normalizePackKey(key),
+        context: {
+            ...context,
+            strategy: 'cag',
+            cache: {
+                storage: 'context-pack',
+                status: 'refresh',
+                dataSignature,
+                path
+            }
+        }
+    };
+    await mkdir(contextPacksDirectory(vaultPath), { recursive: true });
+    await writeFile(path, `${JSON.stringify(stored, null, 2)}\n`, 'utf8');
+    return path;
+};

package/dist/infrastructure/file-index.js

@@ -266,7 +266,8 @@ export const openFileIndex = (vaultPath) => {
                     title: document.title,
                     path: document.path,
                     content: document.content,
-                    tags: document.tags
+                    tags: document.tags,
+                    contextLinks: document.contextLinks ?? []
                 })),
                 edges
             };
@@ -292,7 +293,8 @@ export const openFileIndex = (vaultPath) => {
                         title: document.title,
                         path: document.path,
                         content: '',
-                        tags: document.tags
+                        tags: document.tags,
+                        contextLinks: document.contextLinks ?? []
                     })),
                     edges
                 };
@@ -309,7 +311,8 @@ export const openFileIndex = (vaultPath) => {
                     title: document.title,
                     path: document.path,
                     content: document.content,
-                    tags: document.tags
+                    tags: document.tags,
+                    contextLinks: document.contextLinks ?? []
                 }
                 : undefined;
         },

package/dist/infrastructure/file-system-vault.js

@@ -1,4 +1,4 @@
-import { chmod, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { resolvePath } from './paths.js';
 import { getBucketVaultCachePath, isBucketVaultUri, parseBucketVaultUri, syncBucketVaultToCache, writeBucketMarkdownFile } from './bucket-vault.js';
@@ -109,3 +109,23 @@ export const writeMarkdownFile = async (vaultPath, filename, content) => {
     await chmod(absolutePath, fileMode);
     return absolutePath;
 };
+export const deleteMarkdownFile = async (vaultPath, filename) => {
+    if (isBucketVaultUri(vaultPath)) {
+        throw new Error('Deleting bucket vault notes is not supported from Brainlink yet. Remove bucket objects with your storage provider tooling.');
+    }
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const absolutePath = isAbsolute(filename) ? resolve(filename) : resolve(absoluteVaultPath, filename);
+    if (!isPathInside(absoluteVaultPath, absolutePath)) {
+        throw new Error(`Refusing to delete outside vault: ${absolutePath}`);
+    }
+    if (extname(absolutePath).toLowerCase() !== '.md') {
+        throw new Error(`Refusing to delete non-Markdown vault item: ${absolutePath}`);
+    }
+    const relativePath = relative(absoluteVaultPath, absolutePath);
+    const segments = relativePath.split(/[\\/]+/);
+    if (segments.some((segment) => excludedDirectories.has(segment))) {
+        throw new Error(`Refusing to delete protected vault path: ${relativePath}`);
+    }
+    await rm(absolutePath, { force: false });
+    return absolutePath;
+};

package/dist/infrastructure/index-state.js

@@ -29,6 +29,7 @@ export const readIndexState = async (vaultPath) => {
             updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
             chunkSize: typeof parsed.chunkSize === 'number' ? parsed.chunkSize : 1200,
             embeddingProvider: typeof parsed.embeddingProvider === 'string' ? parsed.embeddingProvider : 'none',
+            graphLinkModelVersion: typeof parsed.graphLinkModelVersion === 'number' ? parsed.graphLinkModelVersion : 1,
             searchPackRowChunkSize: typeof parsed.searchPackRowChunkSize === 'number' ? parsed.searchPackRowChunkSize : 5_000,
             searchPackCompressionLevel: typeof parsed.searchPackCompressionLevel === 'number' ? parsed.searchPackCompressionLevel : 5,
             searchPackUseDictionary: typeof parsed.searchPackUseDictionary === 'boolean' ? parsed.searchPackUseDictionary : true,
@@ -46,6 +47,7 @@ export const writeIndexState = async (vaultPath, state) => {
         updatedAt: new Date().toISOString(),
         chunkSize: state.chunkSize,
         embeddingProvider: state.embeddingProvider,
+        graphLinkModelVersion: state.graphLinkModelVersion,
         searchPackRowChunkSize: state.searchPackRowChunkSize,
         searchPackCompressionLevel: state.searchPackCompressionLevel,
         searchPackUseDictionary: state.searchPackUseDictionary,

package/dist/infrastructure/vault-migration-state.js

@@ -0,0 +1,69 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getBrainlinkHomePath } from './paths.js';
+const defaultState = {
+    byConfigKey: {}
+};
+const statePath = () => join(getBrainlinkHomePath(), 'vault-migration-state.json');
+const sanitizeState = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return defaultState;
+    }
+    const record = value;
+    const byConfigKeyRecord = typeof record.byConfigKey === 'object' && record.byConfigKey !== null ? record.byConfigKey : {};
+    const byConfigKey = Object.entries(byConfigKeyRecord).reduce((state, [key, vault]) => {
+        if (typeof key !== 'string' || key.trim().length === 0) {
+            return state;
+        }
+        if (typeof vault !== 'string' || vault.trim().length === 0) {
+            return state;
+        }
+        return {
+            ...state,
+            [key]: vault.trim()
+        };
+    }, {});
+    return {
+        byConfigKey
+    };
+};
+const readState = async () => {
+    try {
+        const raw = await readFile(statePath(), 'utf8');
+        return sanitizeState(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return defaultState;
+        }
+        throw error;
+    }
+};
+const writeState = async (state) => {
+    const path = statePath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+};
+export const getVaultMigrationStatePath = () => statePath();
+export const getLastConfiguredVaultForKey = async (configKey) => {
+    const state = await readState();
+    const value = state.byConfigKey[configKey];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+};
+export const setLastConfiguredVaultForKey = async (configKey, vault) => {
+    const key = configKey.trim();
+    const value = vault.trim();
+    if (key.length === 0 || value.length === 0) {
+        return;
+    }
+    const state = await readState();
+    if (state.byConfigKey[key] === value) {
+        return;
+    }
+    await writeState({
+        byConfigKey: {
+            ...state.byConfigKey,
+            [key]: value
+        }
+    });
+};

package/dist/infrastructure/volatile-memory.js

@@ -0,0 +1,100 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export const volatileMemoryStoragePath = (vaultPath) => join(vaultPath, '.brainlink', 'volatile.json');
+const emptyStore = () => ({
+    version: 1,
+    entries: []
+});
+const normalizeToken = (value) => value
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase();
+const tokens = (value) => value
+    .match(/[\p{L}\p{N}_-]+/gu)
+    ?.map(normalizeToken)
+    .filter((token) => token.length > 1) ?? [];
+const readStore = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(volatileMemoryStoragePath(vaultPath), 'utf8'));
+        return {
+            version: 1,
+            entries: Array.isArray(parsed.entries) ? parsed.entries.filter(isEntry) : []
+        };
+    }
+    catch {
+        return emptyStore();
+    }
+};
+const writeStore = async (vaultPath, store) => {
+    const target = volatileMemoryStoragePath(vaultPath);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(store, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
+const isEntry = (value) => {
+    const record = value;
+    return Boolean(record &&
+        typeof record.id === 'string' &&
+        typeof record.agentId === 'string' &&
+        typeof record.content === 'string' &&
+        typeof record.createdAt === 'string' &&
+        typeof record.expiresAt === 'string' &&
+        Array.isArray(record.tags));
+};
+const activeEntries = (entries, now = Date.now()) => entries.filter((entry) => Date.parse(entry.expiresAt) > now);
+const scoreEntry = (entry, query) => {
+    const queryTokens = tokens(query);
+    if (queryTokens.length === 0) {
+        return 1;
+    }
+    const haystack = normalizeToken([entry.content, entry.tags.join(' ')].join(' '));
+    return queryTokens.reduce((score, token) => score + (haystack.includes(token) ? 1 : 0), 0);
+};
+export const addVolatileMemory = async (vaultPath, content, agentId = 'shared', ttlMinutes = 240, tags = []) => {
+    const now = new Date();
+    const entry = {
+        id: `volatile-${now.getTime()}-${Math.random().toString(36).slice(2, 10)}`,
+        agentId,
+        content,
+        createdAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + Math.max(1, ttlMinutes) * 60_000).toISOString(),
+        source: 'agent',
+        tags
+    };
+    const store = await readStore(vaultPath);
+    await writeStore(vaultPath, {
+        version: 1,
+        entries: [...activeEntries(store.entries), entry]
+    });
+    return entry;
+};
+export const searchVolatileMemory = async (vaultPath, query, limit, agentId, mode = 'hybrid') => {
+    const store = await readStore(vaultPath);
+    const entries = activeEntries(store.entries)
+        .filter((entry) => (agentId ? entry.agentId === agentId : true))
+        .map((entry) => ({ entry, score: scoreEntry(entry, query) }))
+        .filter(({ score }) => score > 0)
+        .sort((left, right) => right.score - left.score || right.entry.createdAt.localeCompare(left.entry.createdAt))
+        .slice(0, Math.max(0, limit));
+    if (entries.length !== store.entries.length) {
+        await writeStore(vaultPath, { version: 1, entries: activeEntries(store.entries) });
+    }
+    return entries.map(({ entry, score }) => ({
+        title: 'Volatile Memory',
+        path: `volatile://${entry.id}`,
+        content: entry.content,
+        score,
+        searchMode: mode,
+        tags: ['volatile', ...entry.tags],
+        volatile: true,
+        expiresAt: entry.expiresAt
+    }));
+};
+export const clearVolatileMemory = async (vaultPath, agentId) => {
+    const store = await readStore(vaultPath);
+    const active = activeEntries(store.entries);
+    const kept = agentId ? active.filter((entry) => entry.agentId !== agentId) : [];
+    await writeStore(vaultPath, { version: 1, entries: kept });
+    return active.length - kept.length;
+};

package/dist/mcp/http-server.js

@@ -0,0 +1,97 @@
+import { createServer } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { indexVault } from '../application/index-vault.js';
+import { createBrainlinkMcpServer } from './server.js';
+import { runStartupBootstrap } from './startup.js';
+const normalizePath = (path) => {
+    const trimmed = path.trim();
+    if (trimmed.length === 0) {
+        return '/mcp';
+    }
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+};
+const writeJson = (response, statusCode, value) => {
+    response.writeHead(statusCode, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store'
+    });
+    response.end(`${JSON.stringify(value)}\n`);
+};
+const readBearerToken = (authorization) => {
+    const value = Array.isArray(authorization) ? authorization[0] : authorization;
+    const match = value?.match(/^Bearer\s+(.+)$/i);
+    return match?.[1]?.trim();
+};
+const isAuthorized = (expectedToken, authorization) => expectedToken === undefined || readBearerToken(authorization) === expectedToken;
+export const startRemoteMcpServer = async (input) => {
+    const mcpPath = normalizePath(input.path);
+    const startup = await runStartupBootstrap();
+    if (input.shouldIndex) {
+        await indexVault(input.vaultPath);
+    }
+    if (startup.error) {
+        console.error(`Brainlink MCP startup bootstrap warning: ${startup.error}`);
+    }
+    const server = createServer(async (request, response) => {
+        const url = new URL(request.url ?? '/', `http://${request.headers.host ?? input.host}`);
+        if (url.pathname === '/healthz') {
+            writeJson(response, 200, { ok: true });
+            return;
+        }
+        if (url.pathname === '/readyz') {
+            writeJson(response, startup.error ? 503 : 200, {
+                ok: !startup.error,
+                vault: input.vaultPath,
+                agent: input.agent ?? startup.agent ?? '*',
+                ...(startup.error ? { error: startup.error } : {})
+            });
+            return;
+        }
+        if (url.pathname !== mcpPath) {
+            writeJson(response, 404, { error: 'Not found' });
+            return;
+        }
+        if (!isAuthorized(input.token, request.headers.authorization)) {
+            writeJson(response, 401, { error: 'Unauthorized' });
+            return;
+        }
+        try {
+            const mcpServer = createBrainlinkMcpServer();
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true
+            });
+            await mcpServer.connect(transport);
+            await transport.handleRequest(request, response);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeJson(response, 500, { error: message });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(input.port, input.host, () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const port = typeof address === 'object' && address ? address.port : input.port;
+    const publicHost = input.host === '0.0.0.0' ? '127.0.0.1' : input.host;
+    const baseUrl = `http://${publicHost}:${port}`;
+    return {
+        url: `${baseUrl}${mcpPath}`,
+        healthUrl: `${baseUrl}/healthz`,
+        readyUrl: `${baseUrl}/readyz`,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        })
+    };
+};

package/dist/mcp/runtime.js

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+let cachedRuntimeMetadata = null;
+const readPackageMetadata = () => {
+    const packagePath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+    return JSON.parse(readFileSync(packagePath, 'utf8'));
+};
+export const getRuntimeMetadata = () => {
+    if (cachedRuntimeMetadata) {
+        return cachedRuntimeMetadata;
+    }
+    const metadata = readPackageMetadata();
+    cachedRuntimeMetadata = {
+        name: metadata.name ?? 'brainlink',
+        version: metadata.version ?? '0.0.0'
+    };
+    return cachedRuntimeMetadata;
+};
+export const getRuntimeVersion = () => getRuntimeMetadata().version;