@andespindola/brainlink 1.6.4 → 1.6.5

package/README.md

@@ -563,6 +563,7 @@ Available tools:
 - `brainlink_vault_provision`: create a private GitHub repository for the vault with the authenticated `gh` CLI, wire it as `origin`, push the first snapshot, and enable `autoVersion` so later indexed changes are committed and pushed automatically. By default the repository is **encrypted** (`vaultEncryption`): it holds AES-256-GCM ciphertext, decryptable only by a Brainlink instance with the local key.
 - `brainlink_vault_status` / `brainlink_vault_init` / `brainlink_vault_commit` / `brainlink_vault_history` / `brainlink_vault_pull` / `brainlink_vault_restore`: version the vault's canonical Markdown with git (the derived index is git-ignored). Pull and restore reindex changed files automatically so the vault stays immediately searchable.
 - `brainlink_vault_export` / `brainlink_vault_import`: write and read a portable `.blvault` snapshot (gzip envelope of the Markdown with per-file SHA-256). Import verifies checksums, preserves divergent local files as `*.conflict-<ts>.md`, and reindexes.
+- `brainlink_vault_export_bundle` / `brainlink_vault_bundle_list` / `brainlink_vault_import_bundle`: export **every known vault** (the config vault plus `allowedVaults`) into a single portable `.blbundle`, inspect the vaults inside a bundle, and import them back — all vaults to their recorded paths, or a single one via `only` (optionally into `targetVault`). Same checksum verification and conflict preservation as the single-vault snapshot.
 - `brainlink_vault_merge_agents`: losslessly merge one agent namespace into another within the same vault (e.g. `claude-code` → `shared`). Identical notes are skipped, colliding slugs with different content are kept under a `-from-<agent>` name, everything else is moved, and merged notes are aggregated into domain `<context> Hub` notes. Source notes are kept unless `deleteSource` is set; `dryRun` previews the plan.
 - `brainlink_graph`: read indexed graph nodes and weighted links.
 - `brainlink_graph_contexts`: list the visual graph contexts used by the local server.
@@ -966,6 +967,11 @@ blink vault-status
 # Portable snapshot (self-contained, index excluded; import rebuilds it)
 blink vault-export -o vault.blvault
 blink vault-import vault.blvault  # conflicting local edits preserved as *.conflict-<ts>.md
+
+# Multi-vault bundle: every known vault (config vault + allowedVaults) in one file
+blink vault-export --all -o vaults.blbundle
+blink vault-import vaults.blbundle              # restore all vaults to their recorded paths
+blink vault-import vaults.blbundle --only shared --vault ./restored  # restore just one
 ```
 
 Inline credentials in a remote URL are rejected — use SSH or a git credential helper.
@@ -1223,6 +1229,18 @@ When `BRAINLINK_MCP_TOKEN` or `--token` is set, MCP requests must include:
 Authorization: Bearer <token>
 ```
 
+### OAuth (for browser clients like ChatGPT web)
+
+Some clients — notably ChatGPT's web connectors — cannot present a static API key; they only authenticate via OAuth 2.0. Add `--oauth` to run Brainlink as an OAuth 2.0 authorization server (authorization code + PKCE + dynamic client registration) in front of `/mcp`:
+
+```bash
+BRAINLINK_MCP_TOKEN="change-me" \
+BRAINLINK_WEB_USER="you" BRAINLINK_WEB_PASSWORD="change-me" \
+brainlink mcp-server --vault /data/vault --host 0.0.0.0 --port 3333 --oauth
+```
+
+With `--oauth` the server also serves `/.well-known/oauth-authorization-server`, `/.well-known/oauth-protected-resource`, `/register`, `/authorize` (a branded consent page authenticated with the same `BRAINLINK_WEB_USER`/`BRAINLINK_WEB_PASSWORD` credentials), and `/token`. It signs stateless access/refresh tokens with `BRAINLINK_OAUTH_SECRET` (falling back to `BRAINLINK_MCP_TOKEN`); only the registered clients are persisted (`<brainlink-home>/oauth-clients.json`). The two schemes coexist: `/mcp` accepts a valid OAuth access token **or** the static bearer token, so ChatGPT connects via OAuth while Codex/Claude/API clients keep using the static token. Run it behind a TLS-terminating reverse proxy — the public `https` issuer is derived from the forwarded `Host`/`X-Forwarded-Proto`.
+
 For Kubernetes, run Brainlink as a central `Deployment` with a `Service` and a mounted vault volume:
 
 ```yaml

package/dist/cli/commands/write/server-commands.js

@@ -6,6 +6,7 @@ import { startServer } from '../../../application/start-server.js';
 import { resolveWebAuth } from '../../../application/server/web-auth.js';
 import { isBucketVaultPath } from '../../../infrastructure/file-system-vault.js';
 import { startRemoteMcpServer } from '../../../mcp/http-server.js';
+import { getOAuthSecret } from '../../../mcp/oauth.js';
 import { parsePositiveInteger, print, resolveOptions } from '../../runtime.js';
 const spawnDetached = (command, args, envOverrides) => {
     try {
@@ -538,12 +539,22 @@ export const registerServerCommands = (program) => {
         .option('-p, --port <port>', 'remote MCP server port', '3333')
         .option('--path <path>', 'remote MCP endpoint path', '/mcp')
         .option('--token <token>', 'bearer token required for MCP requests')
+        .option('--oauth', 'enable the OAuth 2.0 authorization server (auth code + PKCE + dynamic client registration) for browser clients like ChatGPT web')
         .option('--no-index', 'skip indexing before starting the MCP server')
         .option('--json', 'print machine-readable JSON')
         .description('start a remote MCP server for centralized cluster access')
         .action(async (options) => {
         const resolved = await resolveOptions(options);
         const token = options.token ?? process.env.BRAINLINK_MCP_TOKEN;
+        const oauth = options.oauth === true;
+        // OAuth needs a signing secret (BRAINLINK_OAUTH_SECRET or BRAINLINK_MCP_TOKEN)
+        // and the shared web-auth credentials to authenticate the consent step.
+        if (oauth && getOAuthSecret() === null) {
+            throw new Error('OAuth requires a signing secret: set BRAINLINK_OAUTH_SECRET or BRAINLINK_MCP_TOKEN.');
+        }
+        if (oauth && (await resolveWebAuth()) === null) {
+            throw new Error('OAuth requires login credentials for the consent screen: set BRAINLINK_WEB_USER and BRAINLINK_WEB_PASSWORD.');
+        }
         const server = await startRemoteMcpServer({
             vaultPath: resolved.vault,
             agent: resolved.agent,
@@ -551,7 +562,8 @@ export const registerServerCommands = (program) => {
             port: parsePositiveInteger(options.port ?? '3333', 3333),
             path: options.path ?? '/mcp',
             token,
-            shouldIndex: options.index
+            shouldIndex: options.index,
+            oauth
         });
         print(options.json, {
             url: server.url,
@@ -559,7 +571,7 @@ export const registerServerCommands = (program) => {
             readyUrl: server.readyUrl,
             vault: resolved.vault,
             agent: resolved.agent ?? '*',
-            auth: token === undefined ? 'disabled' : 'bearer'
+            auth: oauth ? (token === undefined ? 'oauth' : 'oauth+bearer') : token === undefined ? 'disabled' : 'bearer'
         }, () => `Brainlink remote MCP server running at ${server.url} (health: ${server.healthUrl}, readiness: ${server.readyUrl})`);
     });
 };

package/dist/mcp/http-server.js

@@ -1,8 +1,13 @@
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { indexVault } from '../application/index-vault.js';
+import { resolveWebAuth, verifyWebPassword } from '../application/server/web-auth.js';
 import { createBrainlinkMcpServer } from './server.js';
+import { createAuthorizePageHtml } from './oauth-authorize-page.js';
+import { buildAuthorizationServerMetadata, buildProtectedResourceMetadata, consumeAuthCode, getClient, getOAuthSecret, issueAuthCode, issueToken, registerClient, verifyPkceS256, verifyToken } from './oauth.js';
 import { runStartupBootstrap } from './startup.js';
+const accessTokenTtlSec = 60 * 60;
+const refreshTokenTtlSec = 30 * 24 * 60 * 60;
 const normalizePath = (path) => {
     const trimmed = path.trim();
     if (trimmed.length === 0) {
@@ -10,19 +15,222 @@ const normalizePath = (path) => {
     }
     return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
 };
-const writeJson = (response, statusCode, value) => {
+const writeJson = (response, statusCode, value, extraHeaders = {}) => {
     response.writeHead(statusCode, {
         'content-type': 'application/json; charset=utf-8',
-        'cache-control': 'no-store'
+        'cache-control': 'no-store',
+        ...extraHeaders
     });
     response.end(`${JSON.stringify(value)}\n`);
 };
+const writeHtml = (response, statusCode, html) => {
+    response.writeHead(statusCode, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+    response.end(html);
+};
+const redirect = (response, location) => {
+    response.writeHead(302, { location, 'cache-control': 'no-store' });
+    response.end();
+};
+const firstHeader = (value) => Array.isArray(value) ? value[0] : value;
 const readBearerToken = (authorization) => {
-    const value = Array.isArray(authorization) ? authorization[0] : authorization;
+    const value = firstHeader(authorization);
     const match = value?.match(/^Bearer\s+(.+)$/i);
     return match?.[1]?.trim();
 };
-const isAuthorized = (expectedToken, authorization) => expectedToken === undefined || readBearerToken(authorization) === expectedToken;
+// Behind a TLS-terminating proxy the process speaks http on loopback, so the
+// public issuer is reconstructed from the forwarded scheme + host. This must be
+// the exact origin the client reached, or OAuth discovery/redirects break.
+const deriveIssuer = (request, fallbackHost) => {
+    const scheme = firstHeader(request.headers['x-forwarded-proto'])?.split(',')[0]?.trim() || 'http';
+    const host = firstHeader(request.headers['x-forwarded-host']) || firstHeader(request.headers.host) || fallbackHost;
+    return `${scheme}://${host}`;
+};
+const readBody = async (request, limitBytes = 1_000_000) => {
+    let body = '';
+    for await (const chunk of request) {
+        body += String(chunk);
+        if (Buffer.byteLength(body, 'utf8') > limitBytes) {
+            throw Object.assign(new Error('Request body too large'), { statusCode: 413 });
+        }
+    }
+    return body;
+};
+const parseBody = (contentType, body) => {
+    if (body.trim().length === 0) {
+        return {};
+    }
+    if ((contentType ?? '').includes('application/json')) {
+        const parsed = JSON.parse(body);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    return Object.fromEntries(new URLSearchParams(body));
+};
+const stringField = (value) => (typeof value === 'string' ? value : '');
+const buildRedirectUrl = (redirectUri, params) => {
+    const url = new URL(redirectUri);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value.length > 0) {
+            url.searchParams.set(key, value);
+        }
+    }
+    return url.toString();
+};
+const readAuthorizeParams = (source) => {
+    const get = (key) => source instanceof URLSearchParams ? source.get(key) ?? '' : stringField(source[key]);
+    return {
+        responseType: get('response_type'),
+        clientId: get('client_id'),
+        redirectUri: get('redirect_uri'),
+        scope: get('scope') || 'mcp',
+        state: get('state'),
+        codeChallenge: get('code_challenge'),
+        codeChallengeMethod: get('code_challenge_method')
+    };
+};
+const hiddenFields = (params) => ({
+    response_type: params.responseType,
+    client_id: params.clientId,
+    redirect_uri: params.redirectUri,
+    scope: params.scope,
+    state: params.state,
+    code_challenge: params.codeChallenge,
+    code_challenge_method: params.codeChallengeMethod
+});
+// Validate the client + redirect_uri before trusting the redirect target. On
+// failure the caller renders an HTML error — it must never redirect to an
+// unvalidated URI.
+const resolveAuthorizeClient = async (params) => {
+    if (params.clientId.length === 0 || params.redirectUri.length === 0) {
+        return { ok: false };
+    }
+    const client = await getClient(params.clientId);
+    if (!client || !client.redirect_uris.includes(params.redirectUri)) {
+        return { ok: false };
+    }
+    return { ok: true, clientName: client.client_name };
+};
+const handleOAuthRoute = async (request, response, url, issuer, mcpPath) => {
+    const method = request.method ?? 'GET';
+    if (method === 'GET' && url.pathname === '/.well-known/oauth-authorization-server') {
+        writeJson(response, 200, buildAuthorizationServerMetadata(issuer));
+        return true;
+    }
+    if (method === 'GET' &&
+        (url.pathname === '/.well-known/oauth-protected-resource' ||
+            url.pathname === `/.well-known/oauth-protected-resource${mcpPath}`)) {
+        writeJson(response, 200, buildProtectedResourceMetadata(issuer, mcpPath));
+        return true;
+    }
+    if (method === 'POST' && url.pathname === '/register') {
+        try {
+            const body = parseBody(firstHeader(request.headers['content-type']), await readBody(request));
+            const redirectUris = Array.isArray(body.redirect_uris) ? body.redirect_uris.map(String) : [];
+            const client = await registerClient({ redirect_uris: redirectUris, client_name: stringField(body.client_name) || undefined });
+            writeJson(response, 201, client);
+        }
+        catch {
+            writeJson(response, 400, { error: 'invalid_client_metadata' });
+        }
+        return true;
+    }
+    if (url.pathname === '/authorize') {
+        const source = method === 'POST'
+            ? parseBody(firstHeader(request.headers['content-type']), await readBody(request))
+            : url.searchParams;
+        const params = readAuthorizeParams(source);
+        const client = await resolveAuthorizeClient(params);
+        if (!client.ok) {
+            writeHtml(response, 400, createAuthorizePageHtml({ error: 'Invalid or unregistered client.', hidden: {} }));
+            return true;
+        }
+        if (params.responseType !== 'code' || params.codeChallenge.length === 0 || params.codeChallengeMethod !== 'S256') {
+            redirect(response, buildRedirectUrl(params.redirectUri, { error: 'invalid_request', state: params.state }));
+            return true;
+        }
+        if (method === 'GET') {
+            writeHtml(response, 200, createAuthorizePageHtml({ clientName: client.clientName, hidden: hiddenFields(params) }));
+            return true;
+        }
+        // POST: authenticate the user against the shared web-auth credentials.
+        const body = source;
+        const auth = await resolveWebAuth();
+        const user = stringField(body.user);
+        const password = stringField(body.password);
+        if (!auth || user !== auth.user || !verifyWebPassword(password, auth.passwordHash)) {
+            writeHtml(response, 401, createAuthorizePageHtml({ clientName: client.clientName, error: 'Invalid username or password.', hidden: hiddenFields(params) }));
+            return true;
+        }
+        const code = issueAuthCode({
+            client_id: params.clientId,
+            redirect_uri: params.redirectUri,
+            code_challenge: params.codeChallenge,
+            user: auth.user,
+            scope: params.scope
+        });
+        redirect(response, buildRedirectUrl(params.redirectUri, { code, state: params.state }));
+        return true;
+    }
+    if (method === 'POST' && url.pathname === '/token') {
+        const secret = getOAuthSecret();
+        if (secret === null) {
+            writeJson(response, 500, { error: 'server_error' });
+            return true;
+        }
+        const body = parseBody(firstHeader(request.headers['content-type']), await readBody(request));
+        const grantType = stringField(body.grant_type);
+        if (grantType === 'authorization_code') {
+            const payload = consumeAuthCode(stringField(body.code));
+            if (!payload ||
+                payload.client_id !== stringField(body.client_id) ||
+                payload.redirect_uri !== stringField(body.redirect_uri) ||
+                !verifyPkceS256(stringField(body.code_verifier), payload.code_challenge)) {
+                writeJson(response, 400, { error: 'invalid_grant' });
+                return true;
+            }
+            writeJson(response, 200, {
+                access_token: issueToken(secret, { sub: payload.user, client_id: payload.client_id, scope: payload.scope, typ: 'access', ttlSec: accessTokenTtlSec }),
+                token_type: 'Bearer',
+                expires_in: accessTokenTtlSec,
+                refresh_token: issueToken(secret, { sub: payload.user, client_id: payload.client_id, scope: payload.scope, typ: 'refresh', ttlSec: refreshTokenTtlSec }),
+                scope: payload.scope
+            });
+            return true;
+        }
+        if (grantType === 'refresh_token') {
+            const claims = verifyToken(secret, stringField(body.refresh_token), 'refresh');
+            if (!claims) {
+                writeJson(response, 400, { error: 'invalid_grant' });
+                return true;
+            }
+            writeJson(response, 200, {
+                access_token: issueToken(secret, { sub: claims.sub, client_id: claims.client_id, scope: claims.scope, typ: 'access', ttlSec: accessTokenTtlSec }),
+                token_type: 'Bearer',
+                expires_in: accessTokenTtlSec,
+                scope: claims.scope
+            });
+            return true;
+        }
+        writeJson(response, 400, { error: 'unsupported_grant_type' });
+        return true;
+    }
+    return false;
+};
+const isMcpAuthorized = (input, authorization) => {
+    const bearer = readBearerToken(authorization);
+    if (input.token === undefined && !input.oauth) {
+        return true;
+    }
+    if (input.token !== undefined && bearer !== undefined && bearer === input.token) {
+        return true;
+    }
+    if (input.oauth) {
+        const secret = getOAuthSecret();
+        if (secret !== null && bearer !== undefined && verifyToken(secret, bearer, 'access') !== null) {
+            return true;
+        }
+    }
+    return false;
+};
 export const startRemoteMcpServer = async (input) => {
     const mcpPath = normalizePath(input.path);
     const startup = await runStartupBootstrap();
@@ -47,12 +255,27 @@ export const startRemoteMcpServer = async (input) => {
             });
             return;
         }
+        try {
+            if (input.oauth && (await handleOAuthRoute(request, response, url, deriveIssuer(request, `${input.host}:${input.port}`), mcpPath))) {
+                return;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeJson(response, 500, { error: message });
+            return;
+        }
         if (url.pathname !== mcpPath) {
             writeJson(response, 404, { error: 'Not found' });
             return;
         }
-        if (!isAuthorized(input.token, request.headers.authorization)) {
-            writeJson(response, 401, { error: 'Unauthorized' });
+        if (!isMcpAuthorized(input, request.headers.authorization)) {
+            const wwwAuthenticate = input.oauth
+                ? {
+                    'www-authenticate': `Bearer resource_metadata="${deriveIssuer(request, `${input.host}:${input.port}`)}/.well-known/oauth-protected-resource"`
+                }
+                : {};
+            writeJson(response, 401, { error: 'Unauthorized' }, wwwAuthenticate);
             return;
         }
         try {

package/dist/mcp/oauth-authorize-page.js

@@ -0,0 +1,199 @@
+// Self-contained branded OAuth authorization/consent page for the Brainlink MCP
+// server. Served as a plain string (inline <style>, no external assets, no
+// framework, no JavaScript) so it works identically for a global npm install.
+// The visual identity mirrors the graph client and auth pages (see
+// client-css.ts / login-page.ts): dark theme on #08131d, the same grid/radial
+// gradient, Crowquill Mono with a monospace fallback, and the #5aa8ff accent.
+// HTML-escape dynamic values. clientName arrives from an untrusted OAuth client
+// and hidden values carry OAuth params, so both must never allow HTML injection.
+const escapeHtml = (value) => value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+const authorizeStyles = () => `:root {
+  color-scheme: dark;
+  --bg: #08131d;
+  --panel: #0d1823;
+  --panel-strong: #112130;
+  --line: rgba(143, 172, 204, 0.18);
+  --text: #edf4ff;
+  --muted: #97a9bd;
+  --accent: #5aa8ff;
+  --accent-weak: rgba(90, 168, 255, 0.18);
+  --danger: #ff6b6b;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  width: 100%;
+  min-height: 100%;
+  margin: 0;
+}
+
+body {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  min-height: 100dvh;
+  padding: 24px;
+  color: var(--text);
+  font-family: "Crowquill Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  background:
+    linear-gradient(rgba(164, 197, 230, 0.05) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(164, 197, 230, 0.05) 1px, transparent 1px),
+    radial-gradient(circle at top, rgba(43, 93, 143, 0.22), transparent 44%),
+    #08131d;
+  background-size: 28px 28px, 28px 28px, auto;
+}
+
+button,
+input {
+  font: inherit;
+}
+
+.auth-card {
+  width: 100%;
+  max-width: 400px;
+  padding: 32px 28px;
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  background: rgba(13, 24, 35, 0.92);
+  box-shadow: 0 24px 80px rgba(1, 6, 13, 0.48);
+  backdrop-filter: blur(8px);
+}
+
+.auth-brand {
+  display: grid;
+  gap: 4px;
+  margin-bottom: 20px;
+}
+
+.auth-brand strong {
+  font-size: 26px;
+  letter-spacing: 0.01em;
+}
+
+.auth-brand span {
+  color: var(--muted);
+  font-size: 13px;
+}
+
+.auth-consent {
+  margin: 0 0 20px;
+  padding: 12px 14px;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  background: rgba(12, 24, 36, 0.6);
+  color: var(--text);
+  font-size: 13px;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+
+.auth-consent strong {
+  color: var(--accent);
+}
+
+.auth-form {
+  display: grid;
+  gap: 16px;
+}
+
+.auth-field {
+  display: grid;
+  gap: 7px;
+}
+
+.auth-field label {
+  color: var(--muted);
+  font-size: 12px;
+  letter-spacing: 0.02em;
+}
+
+.auth-field input {
+  width: 100%;
+  height: 42px;
+  padding: 0 14px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  outline: none;
+  background: rgba(12, 24, 36, 0.94);
+  color: var(--text);
+}
+
+.auth-field input:focus {
+  border-color: var(--accent);
+}
+
+.auth-submit {
+  height: 44px;
+  margin-top: 4px;
+  border: 1px solid var(--accent);
+  border-radius: 8px;
+  background: var(--accent-weak);
+  color: var(--text);
+  cursor: pointer;
+  transition: background 120ms ease, opacity 120ms ease;
+}
+
+.auth-submit:hover,
+.auth-submit:focus {
+  background: rgba(90, 168, 255, 0.3);
+}
+
+.auth-message {
+  margin: 0;
+  font-size: 12px;
+  line-height: 1.4;
+  overflow-wrap: anywhere;
+  color: var(--danger);
+}`;
+const consentLine = (clientName) => {
+    const label = clientName && clientName.length > 0 ? escapeHtml(clientName) : 'An application';
+    return `<strong>${label}</strong> wants to access your Brainlink knowledge graph.`;
+};
+const errorBlock = (error) => error && error.length > 0
+    ? `        <p class="auth-message" role="alert">${escapeHtml(error)}</p>\n`
+    : '';
+const hiddenInputs = (hidden) => Object.keys(hidden)
+    .map((key) => `        <input type="hidden" name="${escapeHtml(key)}" value="${escapeHtml(hidden[key])}" />`)
+    .join('\n');
+export const createAuthorizePageHtml = (input) => {
+    const hidden = hiddenInputs(input.hidden);
+    return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Authorize access · Brainlink</title>
+    <style>${authorizeStyles()}</style>
+  </head>
+  <body>
+    <main class="auth-card">
+      <div class="auth-brand">
+        <strong>Brainlink</strong>
+        <span>Authorize access</span>
+      </div>
+      <p class="auth-consent">${consentLine(input.clientName)}</p>
+      <form class="auth-form" method="post" action="/authorize">
+${hidden ? `${hidden}\n` : ''}        <div class="auth-field">
+          <label for="user">Username</label>
+          <input id="user" name="user" type="text" autocomplete="username" autofocus required />
+        </div>
+        <div class="auth-field">
+          <label for="password">Password</label>
+          <input id="password" name="password" type="password" autocomplete="current-password" required />
+        </div>
+${errorBlock(input.error)}        <button class="auth-submit" type="submit">Authorize</button>
+      </form>
+    </main>
+  </body>
+</html>`;
+};

package/dist/mcp/oauth.js

@@ -0,0 +1,197 @@
+import { createHash, createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getBrainlinkHomePath } from '../infrastructure/paths.js';
+const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+export const getOAuthSecret = () => process.env.BRAINLINK_OAUTH_SECRET?.trim() || process.env.BRAINLINK_MCP_TOKEN?.trim() || null;
+export const buildAuthorizationServerMetadata = (issuer) => ({
+    issuer,
+    authorization_endpoint: `${issuer}/authorize`,
+    token_endpoint: `${issuer}/token`,
+    registration_endpoint: `${issuer}/register`,
+    response_types_supported: ['code'],
+    grant_types_supported: ['authorization_code', 'refresh_token'],
+    code_challenge_methods_supported: ['S256'],
+    token_endpoint_auth_methods_supported: ['none'],
+    scopes_supported: ['mcp']
+});
+export const buildProtectedResourceMetadata = (issuer, mcpPath) => ({
+    resource: `${issuer}${mcpPath}`,
+    authorization_servers: [issuer]
+});
+const constantTimeEqual = (a, b) => {
+    const actual = Buffer.from(a, 'utf8');
+    const expected = Buffer.from(b, 'utf8');
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+};
+export const verifyPkceS256 = (verifier, challenge) => {
+    try {
+        if (!isNonEmptyString(verifier) || !isNonEmptyString(challenge)) {
+            return false;
+        }
+        const computed = createHash('sha256').update(verifier).digest('base64url');
+        return constantTimeEqual(computed, challenge);
+    }
+    catch {
+        return false;
+    }
+};
+const getClientStorePath = () => join(getBrainlinkHomePath(), 'oauth-clients.json');
+const isValidRedirectUri = (value) => {
+    if (!isNonEmptyString(value)) {
+        return false;
+    }
+    try {
+        const url = new URL(value);
+        if (url.protocol === 'https:') {
+            return true;
+        }
+        return url.protocol === 'http:' && url.hostname === 'localhost';
+    }
+    catch {
+        return false;
+    }
+};
+const parseClient = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return null;
+    }
+    const candidate = value;
+    if (!isNonEmptyString(candidate.client_id)) {
+        return null;
+    }
+    if (!Array.isArray(candidate.redirect_uris) ||
+        !candidate.redirect_uris.every(isNonEmptyString)) {
+        return null;
+    }
+    if (candidate.token_endpoint_auth_method !== 'none') {
+        return null;
+    }
+    if (typeof candidate.client_id_issued_at !== 'number') {
+        return null;
+    }
+    const client_name = isNonEmptyString(candidate.client_name) ? candidate.client_name : undefined;
+    return {
+        client_id: candidate.client_id,
+        redirect_uris: candidate.redirect_uris,
+        ...(client_name === undefined ? {} : { client_name }),
+        token_endpoint_auth_method: 'none',
+        client_id_issued_at: candidate.client_id_issued_at
+    };
+};
+const loadClients = async () => {
+    try {
+        const raw = await readFile(getClientStorePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.map(parseClient).filter((client) => client !== null);
+    }
+    catch {
+        return [];
+    }
+};
+const persistClients = async (clients) => {
+    const storePath = getClientStorePath();
+    await mkdir(dirname(storePath), { recursive: true, mode: 0o700 });
+    await writeFile(storePath, JSON.stringify(clients, null, 2), { mode: 0o600 });
+};
+export const registerClient = async (input) => {
+    if (!Array.isArray(input.redirect_uris) ||
+        input.redirect_uris.length === 0 ||
+        !input.redirect_uris.every(isValidRedirectUri)) {
+        throw new Error('invalid redirect_uris');
+    }
+    const client_name = isNonEmptyString(input.client_name) ? input.client_name : undefined;
+    const client = {
+        client_id: randomBytes(16).toString('hex'),
+        redirect_uris: [...input.redirect_uris],
+        ...(client_name === undefined ? {} : { client_name }),
+        token_endpoint_auth_method: 'none',
+        client_id_issued_at: Math.floor(Date.now() / 1000)
+    };
+    const existing = await loadClients();
+    await persistClients([...existing, client]);
+    return client;
+};
+export const getClient = async (clientId) => {
+    const clients = await loadClients();
+    return clients.find((client) => client.client_id === clientId) ?? null;
+};
+const authCodes = new Map();
+export const issueAuthCode = (payload, ttlMs = 60_000) => {
+    const code = randomBytes(24).toString('base64url');
+    authCodes.set(code, { payload, exp: Date.now() + ttlMs });
+    return code;
+};
+export const consumeAuthCode = (code) => {
+    const stored = authCodes.get(code);
+    if (stored === undefined) {
+        return null;
+    }
+    authCodes.delete(code);
+    return Date.now() < stored.exp ? stored.payload : null;
+};
+const parseTokenClaims = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return null;
+    }
+    const candidate = value;
+    if (!isNonEmptyString(candidate.sub) || !isNonEmptyString(candidate.client_id)) {
+        return null;
+    }
+    if (typeof candidate.scope !== 'string') {
+        return null;
+    }
+    if (candidate.typ !== 'access' && candidate.typ !== 'refresh') {
+        return null;
+    }
+    if (typeof candidate.iat !== 'number' || typeof candidate.exp !== 'number') {
+        return null;
+    }
+    return {
+        sub: candidate.sub,
+        client_id: candidate.client_id,
+        scope: candidate.scope,
+        typ: candidate.typ,
+        iat: candidate.iat,
+        exp: candidate.exp
+    };
+};
+export const issueToken = (secret, input) => {
+    const iat = Math.floor(Date.now() / 1000);
+    const claims = {
+        sub: input.sub,
+        client_id: input.client_id,
+        scope: input.scope,
+        typ: input.typ,
+        iat,
+        exp: iat + input.ttlSec
+    };
+    const payloadB64 = Buffer.from(JSON.stringify(claims)).toString('base64url');
+    const signature = createHmac('sha256', secret).update(payloadB64).digest('base64url');
+    return `${payloadB64}.${signature}`;
+};
+export const verifyToken = (secret, token, expectedTyp) => {
+    try {
+        const separatorIndex = token.lastIndexOf('.');
+        if (separatorIndex <= 0) {
+            return null;
+        }
+        const payloadB64 = token.slice(0, separatorIndex);
+        const signature = token.slice(separatorIndex + 1);
+        const expectedSignature = createHmac('sha256', secret).update(payloadB64).digest('base64url');
+        if (!constantTimeEqual(signature, expectedSignature)) {
+            return null;
+        }
+        const claims = parseTokenClaims(JSON.parse(Buffer.from(payloadB64, 'base64url').toString('utf8')));
+        if (claims === null || claims.typ !== expectedTyp) {
+            return null;
+        }
+        return Math.floor(Date.now() / 1000) < claims.exp ? claims : null;
+    }
+    catch {
+        return null;
+    }
+};

package/package.json

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