@alilis/k-hat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aweirdocc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,229 @@
+# K-Hat（khat）
+
+本地 API key 代理管理器，统一管理多个 AI 服务商的密钥并自动轮转。
+
+把 Codex、OpenCode、ZCode 等 Agent Tool 的 API 端点统一指向 khat，之后更换任何 key 都不必再碰这些工具的配置。当一个 key 触发限流（429）、鉴权失败（401）或余额耗尽（402）时，代理自动切换到同 Provider 的其他 key，你的编码工作流不中断。
+
+## 特性
+
+- **单端口双协议**：一个 HTTP 入口同时承载 OpenAI 族与 Anthropic 族协议，按路径区分
+- **模型路由**：按请求中的 `model` 字段路由到目标 Provider，支持 `provider/model` 显式消歧
+- **多 key 加权轮询**：一个 Provider 可配多个 key，按权重平滑分配请求
+- **自动切换**：上游返回 429 / 401 / 402 时标记 key 不可用并换下一个 key 重发（仅首字节前）
+- **加密密钥库**：全部机密（key 明文、访问令牌）存放在 `vault.json` 的加密 payload 中，payload 使用 AES-256-GCM 加密，32 字节主密钥由操作系统绑定（Windows DPAPI）保护，配置文件零机密可安全备份
+- **流式透传**：SSE 逐 chunk 透传，不缓冲、不改写响应内容；客户端断开级联取消上游请求
+- **后台守护与自愈**：`khat start` 在后台启动 supervisor，崩溃后指数退避重启；`khat stop` 优雅停止，`--foreground` 用于诊断
+- **可观测性**：零机密 JSONL 请求日志、按 key 的请求/失败/字节/Token 计数器、`khat log` 与 `/_keys/logs`
+- **本地管理页**：`khat ui` 以 60 秒单次票据打开内嵌 UI，查看状态、日志并恢复不可用 key
+- **零运行时依赖**：纯 Node.js/TypeScript，仅用 Node 内置模块
+
+## 安装
+
+**方式一：从 npm 安装（推荐）**
+
+```bash
+npm install -g @alilis/k-hat
+```
+
+之后任意目录都能直接使用下文的 `khat <命令>`。卸载用 `npm uninstall -g @alilis/k-hat`。
+
+> Windows 下若提示找不到 `khat`，确认 `%APPDATA%\npm` 在 PATH 中（重开终端后生效）。
+
+**方式二：从源码运行**
+
+```bash
+git clone https://github.com/aweirdocc/k-hat
+cd k-hat
+npm install        # 安装依赖的同时会自动编译 TypeScript（prepare 钩子）
+```
+
+执行 `npm link` 注册全局命令，效果与方式一相同；或者不改动全局环境，停留在仓库目录内，把下文所有的 `khat <命令>` 换成 `npm run khat -- <命令>`：
+
+```bash
+npm run khat -- status
+npm run khat -- tui
+```
+
+## 快速开始
+
+```bash
+# 1. 首次初始化：生成加密密钥库 + 访问令牌 + 默认配置
+khat init
+# 输出访问令牌（仅此一次，也可用 khat token show 查看）
+
+# 2. 添加 Provider
+khat provider add deepseek --base-url https://api.deepseek.com --name DeepSeek --protocol openai
+
+# 3. 添加 key（省略 --value 时交互式提示输入；--weight 为该 key 的轮询权重，默认 1）
+khat key add deepseek main --weight 3
+
+# 4. 添加路由：模型名 -> Provider
+khat route add deepseek-v4-pro deepseek
+
+# 5. 后台启动代理（管理变更命令也会在需要时自动启动它）
+khat start
+
+# 6. 查看状态
+khat status
+
+# 7. 打开本地管理页
+khat ui
+
+# 或在终端中打开交互式管理界面
+khat tui
+
+# 8. 停止后台代理
+khat stop
+```
+
+然后在你的工具中把 `base_url` 指向 `http://127.0.0.1:8787/v1`（或 `http://127.0.0.1:8787`，视工具而定），认证令牌填 `khat init` 生成的访问令牌。
+
+## CLI 命令
+
+### 初始化与运行
+
+> 源码运行时无需手动编译：`npm install` 会通过 prepare 钩子自动构建；若手动改过源码，重新执行 `npm run build` 即可。安装为全局命令（`npm link`）后可直接使用 `khat ...`，否则在仓库内用 `npm run khat -- ...`。
+
+| 命令 | 说明 |
+|---|---|
+| `khat init` | 首次初始化：创建密钥库 + 访问令牌 + 默认配置 |
+| `khat start` | 后台启动代理与 supervisor；使用 `--foreground` 以前台模式诊断 |
+| `khat stop` | 请求后台代理优雅停止 |
+| `khat status` | 查看 Provider、key、路由及 key 健康状态 |
+| `khat doctor` | 检测本机 Agent Tool 配置并输出接入提示 |
+| `khat log [--tail <n>]` | 查看最近的脱敏请求日志 |
+| `khat ui` | 签发一次性票据并打开本地管理页 |
+| `khat tui` | 在交互式终端中查看 daemon 状态、Provider/Key、路由和请求日志 |
+
+> Provider、key 和路由的新增、更新、删除与恢复等管理变更通过本地 Admin API 执行；若 daemon 尚未运行，命令会自动启动它。
+
+### 访问令牌
+
+| 命令 | 说明 |
+|---|---|
+| `khat token show` | 打印当前访问令牌 |
+| `khat token rotate` | 轮换访问令牌（需更新所有工具） |
+
+### Provider 管理
+
+| 命令 | 说明 |
+|---|---|
+| `khat provider add <id> --base-url <url> [--name <n>] [--protocol openai\|anthropic]` | 添加 Provider |
+| `khat provider update <id> [--name <n>] [--base-url <url>] [--protocol openai\|anthropic]` | 更新 Provider 名称、上游地址或协议 |
+| `khat provider list` | 列出所有 Provider |
+| `khat provider remove <id>` | 删除 Provider（级联删除其 key 与路由） |
+
+### Key 管理（机密存于加密密钥库）
+
+`--weight <n>`：该 key 在同一 Provider 内多个 key 之间的相对权重（平滑加权轮询，Nginx 同款算法），默认 1。例如 `--weight 3` 与 `--weight 1` 的两个 key，在都可用时请求约按 3:1 分配；权重只影响轮询占比，不影响 key 的可用性。
+
+| 命令 | 说明 |
+|---|---|
+| `khat key add <provider> <id> [--weight <n>] [--value <v>]` | 添加 key（省略 `--value` 时交互式提示） |
+| `khat key update <provider> <id> [--weight <n>] [--value <v>]` | 更新 key 权重或机密值 |
+| `khat key list [<provider>]` | 列出 key（默认脱敏，仅显示尾 4 位） |
+| `khat key remove <provider> <id>` | 删除 key |
+| `khat key enable <provider> <id>` | 将被标记不可用的 key 恢复为可用 |
+| `khat key test <provider> <id> [--model <m>]` | 直连配置的上游发送一次最小请求探活；成功后恢复 key，不会仅因探测返回 401/402/429 就标记 key 不可用 |
+
+### 路由管理
+
+| 命令 | 说明 |
+|---|---|
+| `khat route add <model> <provider>` | 添加「模型名 -> Provider」路由 |
+| `khat route update <model> <provider>` | 更新模型路由指向的 Provider |
+| `khat route list` | 列出所有路由 |
+| `khat route remove <model>` | 删除路由 |
+
+### 环境变量
+
+| 变量 | 说明 |
+|---|---|
+| `KHAT_HOME` | 数据目录（默认 `~/.khat`） |
+| `KHAT_ACCESS_TOKEN` | 覆盖密钥库中的访问令牌（主要供测试） |
+
+## 常见异常与处理
+
+### Key 不可用与自动切换
+
+代理转发路径上，上游返回 **401**（鉴权失败）、**402**（余额耗尽）或 **429**（限流）时，当前 key 会被标记为不可用并跳过，请求自动切换到同一 Provider 的其他可用 key 重发（仅在响应首字节返回前）。若该 Provider 下所有 key 都不可用，请求返回错误。
+
+- **查看**：`khat status` / `khat key list` 中该 key 显示为 `unavailable`，并附最近一次错误（HTTP 状态与时间）。
+- **恢复**：`khat key enable <provider> <id>` 手动恢复；或 `khat key test <provider> <id>` 探活，成功后自动恢复。
+- **注意**：`key test` 直接连接上游探测，**不会**因返回 401/402/429 就把 key 标记为不可用——不可用标记只发生在代理转发路径上。
+
+### CLI 常见报错
+
+| 报错信息 | 原因 | 处理 |
+|---|---|---|
+| `not initialized; run 'khat init' first` | 数据目录尚无密钥库 | 先执行 `khat init` |
+| `no access token found; run khat init` | 密钥库无访问令牌 | `khat init`，或用 `KHAT_ACCESS_TOKEN` 提供 |
+| `port <n> is already occupied by process <pid>` | 端口被其它进程占用 | `khat stop`，或用 `taskkill /PID <pid> /T /F` 结束占用进程 |
+| `daemon started but health check failed` | 后台 daemon 启动异常 | `khat start --foreground` 前台运行观察日志 |
+| `--weight must be a positive integer` | 权重不是正整数 | 传入 ≥1 的整数 |
+| `unknown provider: <x>` / `unknown key: <x/y>` | 引用了不存在的 Provider / Key | 用 `khat provider list` / `khat key list` 核对 |
+| `empty value` | 交互输入 key 值时未输入 | 重新输入，或用 `--value <v>` 提供 |
+| 非 TTY 下 `key add` 交互报错 | 无交互终端且未传 `--value` | 用 `--value <v>` 提供 |
+| `Ticket is invalid or expired` | UI 票据已过期或已使用 | 重新运行 `khat ui` |
+| `khat is not running` | 需要 daemon 的命令但未启动 | 先 `khat start` |
+
+### 代理返回的入口错误
+
+| 状态码 | 含义 | 处理 |
+|---|---|---|
+| 400 | 入口路径与 Provider 协议不匹配，或请求体非法 | 检查工具配置的入口路径与 `base_url` |
+| 401 | 访问令牌无效 | 用 `khat token show` 核对工具里配置的令牌 |
+| 404 | 请求的模型没有匹配的路由 | `khat route add <model> <provider>` |
+| 502 | 上游返回错误（如 key 探活失败） | 查看 `khat log` 与 key 状态 |
+
+### 使用注意事项
+
+- **变更命令会自动拉起 daemon**：`provider / key / route` 等管理命令通过本地 Admin API 执行，若后台服务未运行会自动启动（单写者设计），无需手动 `khat start`。
+- **UI 票据单次有效**：`khat ui` 签发的票据 60 秒有效、只能交换一次会话；管理页保持打开不受影响，重新打开需再次 `khat ui`。
+- **密钥库加密描述**：`vault.json` 是合法 JSON 信封，机密载荷经 AES-256-GCM 加密，32 字节主密钥由 Windows DPAPI 保护；文件本身不是整体二进制密文。
+
+## 协议支持
+
+| 入口路径 | 协议 | 认证头 | 服务的工具 |
+|---|---|---|---|
+| `/v1/chat/completions` | OpenAI Chat | `Authorization: Bearer` | OpenCode、Cursor（部分） |
+| `/v1/responses` | OpenAI Responses | `Authorization: Bearer` | Codex |
+| `/v1/messages` | Anthropic Messages | `x-api-key` + `anthropic-version` | ZCode |
+
+采用**同族直通**策略：OpenAI 入口转发到 OpenAI 上游，Anthropic 入口转发到 Anthropic 上游，只重写认证头与目标 URL，不改写请求体。入口路径与 Provider 协议不匹配时返回 400。
+
+## 数据安全
+
+- **密钥库加密落盘**：`vault.json` 是 JSON 信封；其中 `payload` 使用 AES-256-GCM 加密，32 字节主密钥由 Windows DPAPI（CurrentUser 作用域）保护，key 明文仅存在于守护进程内存
+- **配置零机密**：`config.json` 只存 `vaultRef` 引用，可放心进 Git/网盘备份
+- **日志零机密**：不记录 key 明文、请求/响应体、认证头；CLI 展示 key 默认脱敏
+- **入口双重防护**：所有请求校验 256-bit 访问令牌；默认只绑定 loopback，不对局域网暴露
+- **上游强制 HTTPS**：证书校验，不提供禁用开关（仅 loopback 主机允许明文 http）
+
+## 项目结构
+
+```
+src/
+├── server.ts    # HTTP 服务与转发器（双协议、认证头重写、超时、重试）
+├── router.ts    # 模型名 -> Provider 路由
+├── selector.ts  # 平滑加权轮询
+├── store.ts     # config/state/vault 存储层 + CLI 变更操作
+├── vault.ts     # AES-256-GCM 加密密钥库
+├── config.ts    # 配置加载、校验、原子写入
+├── dpapi.ts     # Windows DPAPI 主密钥保护
+├── types.ts     # 类型定义
+└── cli.ts       # CLI 入口
+test/            # 自动化测试（node:test）
+docs/            # 需求、可行性、概要设计、ADR
+```
+
+## 开发
+
+```bash
+npm test                    # 构建 + 运行全部测试
+npm run build               # 仅编译 TypeScript
+npm start                   # 启动代理
+npm run khat -- status      # 源码运行任意 CLI 子命令
+```
+
+当前状态与设计决策见 [CONTEXT.md](./CONTEXT.md) 与 [docs/](./docs/)。

package/dist/admin.js

@@ -0,0 +1,213 @@
+import { addProvider, updateProvider, removeProvider, addKey, updateKey, removeKey, enableKey, addRoute, updateRoute, removeRoute, maskSecret } from './store.js';
+import { LogWriter } from './logger.js';
+import { join } from 'node:path';
+import { UiSessions, serveUi } from './web-ui.js';
+import { ACCESS_TOKEN_REF, generateAccessToken } from './vault.js';
+// Admin API is the daemon's single-writer surface (ADR-0005). It is reachable
+// only from loopback and behind the proxy access token, so a local non-loopback
+// client or a process without the token cannot mutate config/state/vault.
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+const uiSessions = new UiSessions();
+function json(res, status, value) {
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(value));
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(Buffer.from(chunk));
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new Error('Invalid JSON body');
+    }
+}
+function buildStatus(store) {
+    const token = store.vault.get(ACCESS_TOKEN_REF);
+    return {
+        listen: `http://${store.config.bind}:${store.config.port}`,
+        accessToken: token ? maskSecret(token) : null,
+        providers: store.config.providers.map((provider) => ({
+            id: provider.id,
+            name: provider.name,
+            protocol: provider.protocol,
+            baseUrl: provider.baseUrl,
+            keys: provider.keys.map((key) => {
+                const state = store.states[`${provider.id}/${key.id}`];
+                const secret = store.vault.get(key.vaultRef);
+                return {
+                    id: key.id,
+                    weight: key.weight,
+                    status: state?.status === 'unavailable' ? 'unavailable' : 'available',
+                    lastError: state?.lastError,
+                    secret: secret ? maskSecret(secret) : null,
+                    counters: store.counters[`${provider.id}/${key.id}`] ?? { requests: 0, failed: 0, bytesOut: 0, tokensIn: 0, tokensOut: 0 }
+                };
+            })
+        })),
+        routes: store.config.routes
+    };
+}
+async function route(req, res, store, sessionAuthorized = false) {
+    const url = new URL(req.url, 'http://localhost');
+    const seg = url.pathname.split('/').filter(Boolean); // e.g. ['_keys', 'providers', 'p', 'keys']
+    const sub = seg.slice(1); // drop the leading '_keys'
+    const method = req.method ?? '';
+    if (sub[0] === 'ticket' && sub.length === 1 && method === 'POST') {
+        if (sessionAuthorized)
+            throw new Error('only the access token may create tickets');
+        return json(res, 200, { ticket: uiSessions.createTicket(), expiresInMs: 60_000 });
+    }
+    if (sub[0] === 'ticket' && sub[1] === 'session' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (typeof body.ticket !== 'string')
+            throw new Error('ticket is required');
+        const session = uiSessions.exchange(body.ticket);
+        if (!session)
+            return json(res, 401, { error: { message: 'Ticket is invalid or expired' } });
+        return json(res, 200, { session });
+    }
+    if (sub[0] === 'ui' && method === 'GET') {
+        if (!serveUi(req, res))
+            return json(res, 404, { error: { message: 'Not found' } });
+        return;
+    }
+    if (sub[0] === 'health' && method === 'GET')
+        return json(res, 200, { ok: true });
+    if (sub[0] === 'token' && sub[1] === 'rotate' && method === 'POST') {
+        const token = generateAccessToken();
+        await store.mutate(async () => { store.vault.set(ACCESS_TOKEN_REF, token); await store.vault.save(); });
+        return json(res, 200, { ok: true, token });
+    }
+    if (sub[0] === 'status' && method === 'GET')
+        return json(res, 200, buildStatus(store));
+    if (sub[0] === 'logs' && method === 'GET') {
+        const tail = Number.parseInt(url.searchParams.get('tail') ?? '50', 10);
+        const logs = await new LogWriter(join(store.dir, 'logs')).recent(Number.isFinite(tail) ? tail : 50);
+        const model = url.searchParams.get('model');
+        const key = url.searchParams.get('key');
+        const status = url.searchParams.get('status');
+        return json(res, 200, { logs: logs.filter((entry) => (!model || entry.model === model) && (!key || entry.key === key) && (!status || String(entry.status) === status)) });
+    }
+    if (sub[0] === 'providers') {
+        if (sub.length === 1 && method === 'POST') {
+            const body = await readJsonBody(req);
+            if (!body.id || !body.protocol || !body.baseUrl)
+                throw new Error('id, protocol and baseUrl are required');
+            await store.mutate(() => addProvider(store, { id: body.id, name: body.name, protocol: body.protocol, baseUrl: body.baseUrl }));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 2 && method === 'PUT') {
+            const body = await readJsonBody(req);
+            if (body.name !== undefined && typeof body.name !== 'string')
+                throw new Error('name must be a string');
+            if (body.protocol !== undefined && body.protocol !== 'openai' && body.protocol !== 'anthropic')
+                throw new Error('protocol must be openai or anthropic');
+            if (body.baseUrl !== undefined && typeof body.baseUrl !== 'string')
+                throw new Error('baseUrl must be a string');
+            await store.mutate(() => updateProvider(store, sub[1], body));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 2 && method === 'DELETE') {
+            await store.mutate(() => removeProvider(store, sub[1]));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 3 && sub[2] === 'keys' && method === 'POST') {
+            const body = await readJsonBody(req);
+            if (!body.id || typeof body.value !== 'string')
+                throw new Error('id and value are required');
+            if (body.weight !== undefined && (!Number.isInteger(body.weight) || body.weight < 1))
+                throw new Error('weight must be a positive integer');
+            await store.mutate(() => addKey(store, sub[1], body.id, body.value, body.weight ?? 1));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 4 && sub[2] === 'keys' && method === 'PUT') {
+            const body = await readJsonBody(req);
+            if (body.weight !== undefined && (!Number.isInteger(body.weight) || body.weight < 1))
+                throw new Error('weight must be a positive integer');
+            if (body.value !== undefined && (typeof body.value !== 'string' || !body.value))
+                throw new Error('value must be a non-empty string');
+            await store.mutate(() => updateKey(store, sub[1], sub[3], body));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 4 && sub[2] === 'keys' && method === 'DELETE') {
+            await store.mutate(() => removeKey(store, sub[1], sub[3]));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 5 && sub[2] === 'keys' && sub[4] === 'enable' && method === 'POST') {
+            await store.mutate(() => enableKey(store, sub[1], sub[3]));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 5 && sub[2] === 'keys' && sub[4] === 'probe' && method === 'POST') {
+            const provider = store.config.providers.find((item) => item.id === sub[1]);
+            const key = provider?.keys.find((item) => item.id === sub[3]);
+            if (!provider || !key)
+                throw new Error('unknown provider or key');
+            const secret = store.vault.get(key.vaultRef);
+            const model = store.config.routes.find((item) => item.provider === provider.id)?.model;
+            if (!secret || !model)
+                throw new Error('a key and route model are required for probing');
+            const path = provider.protocol === 'anthropic' ? '/v1/messages' : '/v1/chat/completions';
+            const headers = provider.protocol === 'anthropic' ? { 'content-type': 'application/json', 'x-api-key': secret, 'anthropic-version': '2023-06-01' } : { 'content-type': 'application/json', authorization: `Bearer ${secret}` };
+            const body = provider.protocol === 'anthropic' ? { model, max_tokens: 1, messages: [{ role: 'user', content: 'ping' }] } : { model, max_tokens: 1, messages: [{ role: 'user', content: 'ping' }], stream: false };
+            const response = await fetch(new URL(path, provider.baseUrl), { method: 'POST', headers: headers, body: JSON.stringify(body), signal: AbortSignal.timeout(30_000) });
+            if (response.ok)
+                await store.mutate(() => enableKey(store, provider.id, key.id));
+            return json(res, response.ok ? 200 : 502, { ok: response.ok, status: response.status });
+        }
+    }
+    if (sub[0] === 'routes') {
+        if (sub.length === 1 && method === 'POST') {
+            const body = await readJsonBody(req);
+            if (!body.model || !body.provider)
+                throw new Error('model and provider are required');
+            await store.mutate(() => addRoute(store, body.model, body.provider));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 2 && method === 'PUT') {
+            const body = await readJsonBody(req);
+            if (!body.provider || typeof body.provider !== 'string')
+                throw new Error('provider is required');
+            await store.mutate(() => updateRoute(store, decodeURIComponent(sub[1]), body.provider));
+            return json(res, 200, { ok: true });
+        }
+        if (sub.length === 1 && method === 'DELETE') {
+            // The model goes in the query string: model names are not restricted to
+            // the provider/key id alphabet and may contain characters unsafe in a path segment.
+            const model = url.searchParams.get('model');
+            if (!model)
+                throw new Error('model query parameter is required');
+            await store.mutate(() => removeRoute(store, model));
+            return json(res, 200, { ok: true });
+        }
+    }
+    return json(res, 404, { error: { message: 'Not found' } });
+}
+export async function handleAdmin(req, res, store, accessToken) {
+    const remote = req.socket.remoteAddress ?? '';
+    if (!LOOPBACK.has(remote))
+        return json(res, 403, { error: { message: 'Admin API is reachable only from loopback' } });
+    const url = new URL(req.url, 'http://localhost');
+    const host = req.headers.host;
+    if (host) {
+        const hostname = host.startsWith('[') ? host.slice(1, host.indexOf(']')) : host.split(':')[0];
+        const allowed = hostname === store.config.bind || (store.config.bind === '127.0.0.1' && hostname === 'localhost');
+        if (!allowed)
+            return json(res, 403, { error: { message: 'Invalid Host header' } });
+    }
+    const isUiBootstrap = req.method === 'GET' && (url.pathname === '/_keys/ui' || url.pathname === '/_keys/ui/');
+    const isTicketExchange = req.method === 'POST' && url.pathname === '/_keys/ticket/session';
+    const bearer = req.headers.authorization?.startsWith('Bearer ') ? req.headers.authorization.slice(7) : undefined;
+    const sessionAuthorized = uiSessions.valid(bearer);
+    const currentAccessToken = typeof accessToken === 'function' ? accessToken() : accessToken;
+    const accessAuthorized = currentAccessToken !== undefined && bearer === currentAccessToken;
+    if (!isUiBootstrap && !isTicketExchange && !accessAuthorized && !sessionAuthorized)
+        return json(res, 401, { error: { message: 'Unauthorized' } });
+    try {
+        await route(req, res, store, sessionAuthorized);
+    }
+    catch (error) {
+        json(res, 400, { error: { message: error?.message ?? 'Bad request' } });
+    }
+}