waygate-core 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zhanghaojie513
+
+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

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# waygate-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<div align="center">
+
+**途关家族 · 共享骨架**
+
+两个本地反代工具共用的那 80%
+
+![Node](https://img.shields.io/badge/Node-%E2%89%A520-3C873A?style=flat-square&logo=node.js&logoColor=white)
+![TypeScript](https://img.shields.io/badge/TypeScript-5.7-3178C6?style=flat-square&logo=typescript&logoColor=white)
+![License](https://img.shields.io/badge/License-MIT-blue?style=flat-square)
+
+[waygate-qoder](https://github.com/zhanghaojie513/waygate-qoder) · [waygate-mmcode](https://github.com/zhanghaojie513/waygate-mmcode) · [适配器接口](#给适配器作者)
+
+</div>
+
+---
+
+**不面向最终用户** —— 这个包是两个反代工具共享的骨架，上游协议知识（凭证、翻译、模型清单）由各适配器实现 `Adapter` 接口。
+
+它管的是每个本地反代**都一样**的部分：
+
+- **本地 HTTP 服务** —— OpenAI / Anthropic 双端点、SSE 流原样透传、客户端断连即中止上游
+- **流式与非流式** —— `stream: false` 时自动把 SSE 聚合成单个 `chat.completion` JSON（符合 OpenAI 规范）
+- **入站密钥** —— 自动生成（`sk-<command>-…`）、落盘复用（客户端只需配一次）
+- **配置目录** —— `~/.waygate/<command>/`，跨命令互不干扰
+- **统一 CLI** —— `serve` / `models` / `doctor` / `login` 四个子命令，两家完全同构
+- **扩展子命令** —— 适配器可注册自家专属命令（如 `mmcode checkin`），CLI 统一解析与分发
+- **启动输出** —— 「凭证状态 + 代理地址 + 密钥 + 模型 ID」一屏内复制得走；`--json` 机器可读
+- **自检** —— 端口占用 / 凭证 / 模型清单 / 上游连通，逐项给人话结论 + 下一步动作
+
+## 为什么单独抽包
+
+两个工具的命令面完全一致（`serve` / `models` / `doctor` / `login`），共用一套骨架意味着**改一处两家都受益**，而不是把同一段代码抄两遍（抄两遍的结局必然是只改一处）。
+
+```mermaid
+flowchart LR
+  subgraph adapters [适配器仓库]
+    Q[waygate-qoder<br/>COSY 签名 · DPAPI 解密]
+    M[waygate-mmcode<br/>Anthropic 兼容 · 明文 JSON]
+  end
+  C[waygate-core 包<br/>HTTP 服务 · 密钥 · CLI · 自检]
+  Q -->|Adapter 接口| C
+  M -->|Adapter 接口| C
+
+  style C fill:#EDE9FE,stroke:#8B5CF6,color:#1F2328
+  style Q fill:#FFFFFF,stroke:#D0D7DE,color:#1F2328
+  style M fill:#FFFFFF,stroke:#D0D7DE,color:#1F2328
+  style adapters fill:#F6F8FA,stroke:#D0D7DE
+```
+
+## 给适配器作者
+
+```ts
+import { runCli, type Adapter } from 'waygate-core';
+
+const adapter: Adapter = {
+  command: 'qoc',              // 命令名（决定 ~/.waygate/<command>/ 与 sk-<command>- 密钥前缀）
+  displayName: 'Qoder CN',
+  defaultPort: 8789,
+  upstreamLabel: 'https://gateway.qoder.com.cn',
+  credentialStatus: async () => ({ ok: true, detail: '…' }),
+  login: async () => { /* 导入客户端登录态 */ },
+  listModels: async () => [{ id: 'model-key', displayName: 'Model Name' }],
+  chat: async (body, signal) => ({ stream /* OpenAI 兼容 SSE */, status: 200 }),
+  doctorChecks: async () => [],  // 可选：额外的自检项
+
+  /* 可选：本家专属子命令（core 负责解析、help 展示、分发） */
+  extraCommands: [{
+    name: 'checkin', summary: '每日签到领积分', usage: 'checkin',
+    run: async ({ json }) => (json ? '{}' : '✓ 签到成功'),
+  }],
+};
+await runCli(adapter, { version: '0.1.0' });
+```
+
+实现核心钩子，core 会替你处理 HTTP 服务、密钥管理、CLI 解析、启动输出、自检——你只写上游协议那一层。
+
+> 安装：`npm i waygate-core`（仓库同时保留 `dist/`，供 GitHub 直装兜底）。
+
+## 相关项目
+
+- **[waygate-qoder](https://github.com/zhanghaojie513/waygate-qoder)** —— Qoder CN 本地反代（命令 `qoc`）
+- **[waygate-mmcode](https://github.com/zhanghaojie513/waygate-mmcode)** —— MiniMax Code 本地反代（命令 `mmcode`）
+- **[relay-station](https://github.com/zhanghaojie513/relay-station)** —— 同一作者的完整多提供商反代（含控制台、用量统计）
+
+## License
+
+MIT

package/dist/aggregate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SSE 聚合器：把 OpenAI 形状的 SSE chunk 流拼成单个 `chat.completion` JSON。
+ *
+ * 用于 `stream: false` 的入站请求 —— 上游恒走流式（两家协议如此），代理在出口把
+ * 流聚合成非流式响应返回给客户端。这是 OpenAI 规范的要求：`stream:false` 应返回
+ * 单个 JSON 而非 SSE。
+ *
+ * 聚合规则（只认真实出现的字段，不编造）：
+ *   · `choices[0].delta.content` 拼接为 `message.content`
+ *   · `choices[0].delta.reasoning_content` 拼接为 `message.reasoning_content`（DeepSeek 惯例）
+ *   · `choices[0].delta.role` 取首个非空值
+ *   · `choices[0].delta.tool_calls` 累积（按 index 合并 arguments 分片）
+ *   · `finish_reason` 取最后一个非空值
+ *   · `usage` 取末帧（含 `stream_options.include_usage` 的独立末帧）
+ *   · `id` / `model` / `created` 取首个 chunk 的值
+ */
+/**
+ * 聚合一整个 SSE 流为单个 completion 对象。
+ * 输入是 OpenAI SSE 字节流（与流式透传相同格式），输出是 JSON 字符串。
+ *
+ * @throws 如果流内不含任何有效 chunk（上游异常）
+ */
+export declare function aggregateSseToJson(stream: ReadableStream<Uint8Array>): Promise<string>;

package/dist/aggregate.js

@@ -0,0 +1,150 @@
+/**
+ * SSE 聚合器：把 OpenAI 形状的 SSE chunk 流拼成单个 `chat.completion` JSON。
+ *
+ * 用于 `stream: false` 的入站请求 —— 上游恒走流式（两家协议如此），代理在出口把
+ * 流聚合成非流式响应返回给客户端。这是 OpenAI 规范的要求：`stream:false` 应返回
+ * 单个 JSON 而非 SSE。
+ *
+ * 聚合规则（只认真实出现的字段，不编造）：
+ *   · `choices[0].delta.content` 拼接为 `message.content`
+ *   · `choices[0].delta.reasoning_content` 拼接为 `message.reasoning_content`（DeepSeek 惯例）
+ *   · `choices[0].delta.role` 取首个非空值
+ *   · `choices[0].delta.tool_calls` 累积（按 index 合并 arguments 分片）
+ *   · `finish_reason` 取最后一个非空值
+ *   · `usage` 取末帧（含 `stream_options.include_usage` 的独立末帧）
+ *   · `id` / `model` / `created` 取首个 chunk 的值
+ */
+/**
+ * 聚合一整个 SSE 流为单个 completion 对象。
+ * 输入是 OpenAI SSE 字节流（与流式透传相同格式），输出是 JSON 字符串。
+ *
+ * @throws 如果流内不含任何有效 chunk（上游异常）
+ */
+export async function aggregateSseToJson(stream) {
+    const decoder = new TextDecoder();
+    const agg = { content: '' };
+    let finish = null;
+    let usage;
+    let id = '';
+    let model = '';
+    let created = 0;
+    let sawChunk = false;
+    const reader = stream.getReader();
+    try {
+        let buf = '';
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            /* SSE 帧按 \n\n 分隔；最后一段可能不完整（等下一块）。 */
+            const frames = buf.split('\n\n');
+            buf = frames.pop() ?? '';
+            for (const frame of frames) {
+                const dataLine = frame
+                    .split('\n')
+                    .find((l) => l.startsWith('data:'));
+                if (!dataLine)
+                    continue;
+                const payload = dataLine.slice(5).trim();
+                if (!payload || payload === '[DONE]')
+                    continue;
+                let chunk;
+                try {
+                    chunk = JSON.parse(payload);
+                }
+                catch {
+                    continue; /* 非 JSON 帧（上游杂音），跳过 */
+                }
+                sawChunk = true;
+                if (!id && typeof chunk.id === 'string')
+                    id = chunk.id;
+                if (!model && typeof chunk.model === 'string')
+                    model = chunk.model;
+                if (!created && typeof chunk.created === 'number')
+                    created = chunk.created;
+                /* usage 独立末帧（choices 为空）或挂在内容帧上 —— 都取。 */
+                const u = chunk.usage;
+                if (u && typeof u === 'object')
+                    usage = u;
+                const choices = chunk.choices;
+                if (!Array.isArray(choices) || choices.length === 0)
+                    continue;
+                const c = choices[0];
+                const fr = c.finish_reason;
+                if (typeof fr === 'string' && fr)
+                    finish = fr;
+                const delta = c.delta;
+                if (!delta || typeof delta !== 'object')
+                    continue;
+                const d = delta;
+                if (typeof d.role === 'string' && d.role && !agg.role)
+                    agg.role = d.role;
+                if (typeof d.content === 'string')
+                    agg.content += d.content;
+                if (typeof d.reasoning_content === 'string') {
+                    agg.reasoning_content = (agg.reasoning_content ?? '') + d.reasoning_content;
+                }
+                if (Array.isArray(d.tool_calls)) {
+                    agg.tool_calls = agg.tool_calls ?? [];
+                    for (const tc of d.tool_calls) {
+                        if (!tc || typeof tc !== 'object')
+                            continue;
+                        const t = tc;
+                        const idx = typeof t.index === 'number' ? t.index : 0;
+                        const fn = (t.function ?? {});
+                        const existing = agg.tool_calls.find((x) => x.index === idx);
+                        if (existing) {
+                            if (typeof fn.name === 'string' && fn.name)
+                                existing.function.name = fn.name;
+                            if (typeof fn.arguments === 'string')
+                                existing.function.arguments += fn.arguments;
+                        }
+                        else {
+                            agg.tool_calls.push({
+                                index: idx,
+                                id: typeof t.id === 'string' ? t.id : `call_${idx}`,
+                                type: typeof t.type === 'string' ? t.type : 'function',
+                                function: {
+                                    name: typeof fn.name === 'string' ? fn.name : '',
+                                    arguments: typeof fn.arguments === 'string' ? fn.arguments : '',
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (!sawChunk)
+        throw new Error('上游流不含有效 chunk（聚合失败）');
+    /* tool_calls 的 index 在最终响应中不出现（OpenAI 规范）。 */
+    const toolCalls = agg.tool_calls?.map((tc) => ({
+        id: tc.id ?? '',
+        type: tc.type ?? 'function',
+        function: { name: tc.function?.name ?? '', arguments: tc.function?.arguments ?? '' },
+    }));
+    const completion = {
+        id: id || 'chatcmpl-unknown',
+        object: 'chat.completion',
+        created: created || Math.floor(Date.now() / 1000),
+        model: model || 'unknown',
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: agg.role ?? 'assistant',
+                    content: agg.content,
+                    ...(agg.reasoning_content !== undefined ? { reasoning_content: agg.reasoning_content } : {}),
+                    ...(toolCalls && toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                },
+                finish_reason: finish,
+            },
+        ],
+        ...(usage ? { usage } : {}),
+    };
+    return JSON.stringify(completion);
+}

package/dist/cli.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 统一 CLI（两家命令共用这套子命令：serve / models / doctor / login）。
+ *
+ * 设计目标：**学一个会两个** —— `qoc` 与 `mmcode` 的子命令、参数完全一致，
+ * 只有命令名不同。适配器只提供业务钩子（凭证/模型/聊天），CLI 由这里统一处理。
+ */
+import { maskKey } from './config.js';
+import type { Adapter } from './types.js';
+export interface CliMeta {
+    /** 包版本（各仓 package.json 的 version）。 */
+    version: string;
+}
+export interface ParsedArgs {
+    /** 内置子命令，或适配器自定义子命令名。 */
+    command: 'serve' | 'models' | 'doctor' | 'login' | 'help' | (string & {});
+    host: string;
+    port?: number;
+    key?: string;
+    json: boolean;
+    verbose: boolean;
+    /** 传给自定义子命令的剩余位置参数。 */
+    rest: string[];
+}
+export declare function parseArgs(argv: string[], adapter: Adapter): ParsedArgs;
+export declare function helpText(adapter: Adapter): string;
+/** 命令入口：适配器 + 版本 → 完整 CLI 行为。返回进程退出码。 */
+export declare function runCli(adapter: Adapter, meta: CliMeta, argv?: string[]): Promise<number>;
+export { maskKey };

package/dist/cli.js

@@ -0,0 +1,183 @@
+/**
+ * 统一 CLI（两家命令共用这套子命令：serve / models / doctor / login）。
+ *
+ * 设计目标：**学一个会两个** —— `qoc` 与 `mmcode` 的子命令、参数完全一致，
+ * 只有命令名不同。适配器只提供业务钩子（凭证/模型/聊天），CLI 由这里统一处理。
+ */
+import { resolveKey, maskKey } from './config.js';
+import { runDoctor, renderDoctor } from './doctor.js';
+import { renderReady, renderReadyJson } from './report.js';
+import { startServer } from './server.js';
+const BUILTIN = ['serve', 'models', 'doctor', 'login', 'help', '--help', '-h'];
+export function parseArgs(argv, adapter) {
+    const args = [...argv];
+    const known = new Set([...BUILTIN, ...(adapter.extraCommands ?? []).map((c) => c.name)]);
+    let command = 'serve';
+    if (args[0] && known.has(args[0])) {
+        const c = args.shift();
+        command = c === '--help' || c === '-h' ? 'help' : c;
+    }
+    let host = '127.0.0.1';
+    let port;
+    let key;
+    let json = false;
+    let verbose = false;
+    const rest = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === undefined)
+            break;
+        if (a === '--host')
+            host = args[++i] ?? host;
+        else if (a === '--port') {
+            const v = Number(args[++i]);
+            if (!Number.isInteger(v) || v < 1 || v > 65535)
+                throw new Error(`--port 非法：${args[i]}`);
+            port = v;
+        }
+        else if (a === '--key')
+            key = args[++i];
+        else if (a === '--json')
+            json = true;
+        else if (a === '--verbose')
+            verbose = true;
+        else if (a === '--help' || a === '-h')
+            command = 'help';
+        else if (a.startsWith('-'))
+            throw new Error(`未知参数：${a}（用 --help 看用法）`);
+        else
+            rest.push(a); /* 自定义子命令的位置参数（如 checkin --all） */
+    }
+    return { command, host, port, key, json, verbose, rest };
+}
+export function helpText(adapter) {
+    const c = adapter.command;
+    return [
+        `途关 · ${adapter.displayName} 反代（命令 ${c}）`,
+        '',
+        '用法：',
+        `  ${c}                 启动反代（同 ${c} serve），打印模型 ID 与代理地址`,
+        `  ${c} serve           同上`,
+        `  ${c} models          只列出模型 ID（不起服务）`,
+        `  ${c} doctor          自检：端口 / 凭证 / 模型 / 上游连通`,
+        `  ${c} login           导入或刷新本机 ${adapter.displayName} 客户端的登录态`,
+        ...(adapter.extraCommands?.length
+            ? ['', `${adapter.displayName} 专属：`, ...adapter.extraCommands.map((x) => `  ${c} ${x.usage.padEnd(17)}${x.summary}`)]
+            : []),
+        '',
+        '参数：',
+        '  --port <n>          监听端口（默认 ' + adapter.defaultPort + '）',
+        '  --host <addr>       监听地址（默认 127.0.0.1；0.0.0.0 会暴露给局域网，谨慎）',
+        '  --key <sk-…>        指定入站密钥（默认自动生成并缓存到 ~/.waygate/' + c + '/key）',
+        '  --json              机器可读输出',
+        '  --verbose           打印每个请求的路由日志',
+        '  --help              显示本帮助',
+        '',
+        '只读取你本机的客户端登录态、在上游与客户端之间本地转发；不上传任何数据。',
+    ].join('\n');
+}
+/** 命令入口：适配器 + 版本 → 完整 CLI 行为。返回进程退出码。 */
+export async function runCli(adapter, meta, argv = process.argv.slice(2)) {
+    let parsed;
+    try {
+        parsed = parseArgs(argv, adapter);
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        return 2;
+    }
+    if (parsed.command === 'help') {
+        process.stdout.write(helpText(adapter) + '\n');
+        return 0;
+    }
+    /* 适配器自定义子命令（如 mmcode 的 checkin / credits）。 */
+    const extra = adapter.extraCommands?.find((x) => x.name === parsed.command);
+    if (extra) {
+        try {
+            const out = await extra.run({ json: parsed.json, args: parsed.rest });
+            if (out)
+                process.stdout.write(out.endsWith('\n') ? out : out + '\n');
+            return 0;
+        }
+        catch (err) {
+            process.stderr.write(`${extra.name} 失败：${err.message}\n`);
+            return 1;
+        }
+    }
+    if (parsed.command === 'login') {
+        try {
+            await adapter.login();
+            const cred = await adapter.credentialStatus();
+            process.stdout.write(`凭证    ${cred.ok ? '✓' : '✗'} ${cred.detail}\n`);
+            return cred.ok ? 0 : 1;
+        }
+        catch (err) {
+            process.stderr.write(`登录态导入失败：${err.message}\n`);
+            return 1;
+        }
+    }
+    const host = parsed.host;
+    const port = parsed.port ?? adapter.defaultPort;
+    if (parsed.command === 'doctor') {
+        const results = await runDoctor(adapter, host, port);
+        process.stdout.write(renderDoctor(results) + '\n');
+        return results.every((r) => r.ok) ? 0 : 1;
+    }
+    const key = resolveKey(adapter.command, parsed.key);
+    const cred = await adapter.credentialStatus();
+    const models = await adapter.listModels().catch(() => []);
+    if (parsed.command === 'models') {
+        if (parsed.json) {
+            process.stdout.write(JSON.stringify({ models: models.map((m) => ({ id: m.id, displayName: m.displayName ?? null })) }, null, 2) + '\n');
+        }
+        else {
+            for (const m of models)
+                process.stdout.write(`${m.id}${m.displayName && m.displayName !== m.id ? '   ' + m.displayName : ''}\n`);
+        }
+        return models.length > 0 ? 0 : 1;
+    }
+    /* serve */
+    const ready = {
+        command: adapter.command,
+        displayName: adapter.displayName,
+        version: meta.version,
+        upstream: adapter.upstreamLabel,
+        host,
+        port,
+        key,
+        credential: cred,
+        models,
+    };
+    if (!cred.ok && !parsed.json) {
+        process.stderr.write(`凭证未就绪：${cred.detail}\n先运行：${adapter.command} login\n`);
+    }
+    try {
+        const running = await startServer(adapter, {
+            host,
+            port,
+            apiKey: key,
+            verbose: parsed.verbose,
+            log: (line) => process.stdout.write(line + '\n'),
+        });
+        process.stdout.write((parsed.json ? renderReadyJson({ ...ready, port: running.port }) : renderReady({ ...ready, port: running.port })) + '\n');
+        const shutdown = () => {
+            process.stdout.write('\n正在停止…\n');
+            void running.close().then(() => process.exit(0));
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        return await new Promise(() => {
+            /* 常驻：直到信号触发 exit */
+        });
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'EADDRINUSE') {
+            process.stderr.write(`端口 ${port} 已被占用 —— 换一个：${adapter.command} --port ${port + 1}\n`);
+            return 1;
+        }
+        process.stderr.write(`启动失败：${e.message}\n`);
+        return 1;
+    }
+}
+export { maskKey };

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 配置目录与入站密钥管理。
+ *
+ * 配置落在用户主目录下的 `.waygate/`（跨平台）：
+ *   ~/.waygate/<command>/           每家一个子目录（qoc / mmcode 互不干扰）
+ *   ~/.waygate/<command>/key        入站密钥（sk-<command>-…，0600）
+ *   ~/.waygate/<command>/credential.json   适配器自管的凭证副本（可选）
+ *
+ * 为什么密钥要落盘：客户端（Cursor / Claude Code 等）只接受**稳定的**密钥串；
+ * 每次启动随机生成会让用户在客户端里反复改配置。落盘一次、后续复用。
+ */
+/** 家族配置根目录（`~/.waygate`）。可用 WAYGATE_HOME 覆盖（测试/便携部署用）。 */
+export declare function waygateHome(): string;
+/** 某家命令的配置目录（`~/.waygate/<command>`），确保存在。 */
+export declare function commandDir(command: string): string;
+/** 入站密钥的落盘形态：`sk-<command>-<32hex>`。 */
+export declare function generateKey(command: string): string;
+/**
+ * 取该命令的入站密钥：已落盘则复用，否则生成并落盘（0600）。
+ * `override`（CLI `--key`）优先，不落盘 —— 用户显式指定即由用户自管。
+ */
+export declare function resolveKey(command: string, override?: string): string;
+/** 打印用：密钥打码（只留头尾）。 */
+export declare function maskKey(key: string): string;

package/dist/config.js

@@ -0,0 +1,62 @@
+/**
+ * 配置目录与入站密钥管理。
+ *
+ * 配置落在用户主目录下的 `.waygate/`（跨平台）：
+ *   ~/.waygate/<command>/           每家一个子目录（qoc / mmcode 互不干扰）
+ *   ~/.waygate/<command>/key        入站密钥（sk-<command>-…，0600）
+ *   ~/.waygate/<command>/credential.json   适配器自管的凭证副本（可选）
+ *
+ * 为什么密钥要落盘：客户端（Cursor / Claude Code 等）只接受**稳定的**密钥串；
+ * 每次启动随机生成会让用户在客户端里反复改配置。落盘一次、后续复用。
+ */
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** 家族配置根目录（`~/.waygate`）。可用 WAYGATE_HOME 覆盖（测试/便携部署用）。 */
+export function waygateHome() {
+    const override = (process.env.WAYGATE_HOME ?? '').trim();
+    return override || join(homedir(), '.waygate');
+}
+/** 某家命令的配置目录（`~/.waygate/<command>`），确保存在。 */
+export function commandDir(command) {
+    const dir = join(waygateHome(), command);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+/** 入站密钥的落盘形态：`sk-<command>-<32hex>`。 */
+export function generateKey(command) {
+    return `sk-${command}-${randomBytes(16).toString('hex')}`;
+}
+/**
+ * 取该命令的入站密钥：已落盘则复用，否则生成并落盘（0600）。
+ * `override`（CLI `--key`）优先，不落盘 —— 用户显式指定即由用户自管。
+ */
+export function resolveKey(command, override) {
+    if (override && override.trim())
+        return override.trim();
+    const file = join(commandDir(command), 'key');
+    try {
+        const existing = readFileSync(file, 'utf8').trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        /* 首次：生成 */
+    }
+    const key = generateKey(command);
+    writeFileSync(file, key + '\n', { mode: 0o600 });
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        /* Windows 上 chmod 语义有限，忽略 */
+    }
+    return key;
+}
+/** 打印用：密钥打码（只留头尾）。 */
+export function maskKey(key) {
+    if (key.length <= 14)
+        return key.slice(0, 4) + '…';
+    return `${key.slice(0, 12)}…${key.slice(-4)}`;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 自检（`doctor` 子命令）：把「为什么用不了」拆成可逐项排查的检查清单。
+ *
+ * 顺序按「用户能自己解决」靠前：端口占用 → 凭证 → 模型 → 上游连通。
+ * 每项都给人话结论 + 下一步动作（不抛栈）。
+ */
+import type { Adapter } from './types.js';
+export interface CheckResult {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+/** 端口是否可用（能监听即视为可用）。 */
+export declare function checkPortFree(host: string, port: number): Promise<CheckResult>;
+/** 跑完整自检（适配器提供凭证/模型/上游项）。 */
+export declare function runDoctor(adapter: Adapter, host: string, port: number): Promise<CheckResult[]>;
+export declare function renderDoctor(results: CheckResult[]): string;

package/dist/doctor.js

@@ -0,0 +1,57 @@
+/**
+ * 自检（`doctor` 子命令）：把「为什么用不了」拆成可逐项排查的检查清单。
+ *
+ * 顺序按「用户能自己解决」靠前：端口占用 → 凭证 → 模型 → 上游连通。
+ * 每项都给人话结论 + 下一步动作（不抛栈）。
+ */
+import { createServer } from 'node:net';
+/** 端口是否可用（能监听即视为可用）。 */
+export async function checkPortFree(host, port) {
+    const bindHost = host === '0.0.0.0' || host === '::' ? '0.0.0.0' : host;
+    return new Promise((resolve) => {
+        const probe = createServer();
+        probe.once('error', (err) => {
+            resolve({
+                name: `端口 ${port}`,
+                ok: false,
+                detail: err.code === 'EADDRINUSE'
+                    ? `已被占用 —— 换一个端口（--port ${port + 1}），或先停掉占用该端口的程序`
+                    : `无法监听：${err.message}`,
+            });
+        });
+        probe.listen(port, bindHost, () => {
+            probe.close(() => resolve({ name: `端口 ${port}`, ok: true, detail: '可用' }));
+        });
+    });
+}
+/** 跑完整自检（适配器提供凭证/模型/上游项）。 */
+export async function runDoctor(adapter, host, port) {
+    const results = [];
+    results.push(await checkPortFree(host, port));
+    const cred = await adapter.credentialStatus();
+    results.push({ name: '凭证', ok: cred.ok, detail: cred.detail + (cred.source ? `（${cred.source}）` : '') });
+    if (cred.ok) {
+        try {
+            const models = await adapter.listModels();
+            results.push({
+                name: '模型清单',
+                ok: models.length > 0,
+                detail: models.length > 0 ? `${models.length} 个：${models.slice(0, 3).map((m) => m.id).join('、')}${models.length > 3 ? ' …' : ''}` : '拉不到模型 —— 上游可能改了接口，或凭证已失效',
+            });
+        }
+        catch (err) {
+            results.push({ name: '模型清单', ok: false, detail: err.message });
+        }
+    }
+    if (adapter.doctorChecks) {
+        results.push(...(await adapter.doctorChecks()));
+    }
+    return results;
+}
+export function renderDoctor(results) {
+    const lines = results.map((r) => `${r.ok ? '✓' : '✗'} ${r.name}    ${r.detail}`);
+    const allOk = results.every((r) => r.ok);
+    lines.push('');
+    lines.push(allOk ? '全部通过 —— 直接运行对应命令即可启动反代。' : '有项目未通过 —— 按上面的提示处理后重跑 doctor。');
+    return lines.join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @waygate/core —— Waygate 家族共享骨架。
+ *
+ * 提供：本地反代 HTTP 服务、入站密钥、配置目录、启动输出、自检、统一 CLI。
+ * 上游协议知识（凭证、翻译、模型清单）由各适配器仓库实现 `Adapter` 接口。
+ */
+export type { Adapter, ChatMessage, ChatRequestBody, CredentialStatus, ModelEntry, UpstreamCallResult, } from './types.js';
+export { waygateHome, commandDir, resolveKey, generateKey, maskKey } from './config.js';
+export { startServer, type ServeOptions, type RunningServer } from './server.js';
+export { aggregateSseToJson } from './aggregate.js';
+export { renderReady, renderReadyJson, type ReadyReport } from './report.js';
+export { runDoctor, renderDoctor, checkPortFree, type CheckResult } from './doctor.js';
+export { runCli, parseArgs, helpText, type CliMeta, type ParsedArgs } from './cli.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * @waygate/core —— Waygate 家族共享骨架。
+ *
+ * 提供：本地反代 HTTP 服务、入站密钥、配置目录、启动输出、自检、统一 CLI。
+ * 上游协议知识（凭证、翻译、模型清单）由各适配器仓库实现 `Adapter` 接口。
+ */
+export { waygateHome, commandDir, resolveKey, generateKey, maskKey } from './config.js';
+export { startServer } from './server.js';
+export { aggregateSseToJson } from './aggregate.js';
+export { renderReady, renderReadyJson } from './report.js';
+export { runDoctor, renderDoctor, checkPortFree } from './doctor.js';
+export { runCli, parseArgs, helpText } from './cli.js';

package/dist/report.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 启动输出（`serve` / `models` 共用）。
+ *
+ * 人读版：模型 ID + 代理地址 + 密钥，一屏内复制得走。
+ * `--json`：同信息机器可读（给脚本/其他工具消费）。
+ */
+import type { CredentialStatus, ModelEntry } from './types.js';
+export interface ReadyReport {
+    command: string;
+    displayName: string;
+    version: string;
+    adapterVersion?: string;
+    upstream: string;
+    host: string;
+    port: number;
+    key: string;
+    credential: CredentialStatus;
+    models: ModelEntry[];
+}
+export declare function renderReady(r: ReadyReport): string;
+export declare function renderReadyJson(r: ReadyReport): string;

package/dist/report.js

@@ -0,0 +1,52 @@
+/**
+ * 启动输出（`serve` / `models` 共用）。
+ *
+ * 人读版：模型 ID + 代理地址 + 密钥，一屏内复制得走。
+ * `--json`：同信息机器可读（给脚本/其他工具消费）。
+ */
+import { maskKey } from './config.js';
+/** 代理地址（回环时省略 scheme 中的主机歧义，直接用用户可复制的完整 URL）。 */
+function baseUrl(host, port) {
+    const h = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+    return `http://${h}:${port}`;
+}
+export function renderReady(r) {
+    const lines = [];
+    lines.push(`途关 · ${r.displayName} 反代 v${r.version}`);
+    lines.push('');
+    lines.push(`凭证    ${r.credential.ok ? '✓' : '✗'} ${r.credential.detail}`);
+    lines.push(`上游    ${r.upstream}`);
+    lines.push(`代理    ${baseUrl(r.host, r.port)}`);
+    lines.push(`密钥    ${maskKey(r.key)}`);
+    if (r.host === '0.0.0.0' || r.host === '::') {
+        lines.push('');
+        lines.push(`⚠️  正在监听所有网络接口（${r.host}）—— 局域网内任何设备都能访问你的订阅。`);
+        lines.push('    如非必要，请改用默认的 127.0.0.1。');
+    }
+    lines.push('');
+    lines.push('模型 ID（填进你的客户端）：');
+    if (r.models.length === 0)
+        lines.push('  （暂无 —— 先跑一次 doctor 排查）');
+    for (const m of r.models) {
+        const hint = m.displayName && m.displayName !== m.id ? `   ${m.displayName}` : '';
+        lines.push(`  ${m.id}${hint}`);
+    }
+    lines.push('');
+    lines.push(`把上面的「代理地址 + 密钥」填进 Cursor / Claude Code / Cherry Studio 等客户端即可。`);
+    lines.push('端点：POST /v1/chat/completions（OpenAI 兼容）· POST /v1/messages（Anthropic 兼容）· GET /v1/models');
+    lines.push('按 Ctrl+C 停止。');
+    return lines.join('\n');
+}
+export function renderReadyJson(r) {
+    return JSON.stringify({
+        command: r.command,
+        displayName: r.displayName,
+        version: r.version,
+        upstream: r.upstream,
+        proxyUrl: baseUrl(r.host, r.port),
+        key: r.key,
+        credential: { ok: r.credential.ok, detail: r.credential.detail, source: r.credential.source ?? null },
+        models: r.models.map((m) => ({ id: m.id, displayName: m.displayName ?? null })),
+        endpoints: { openai: '/v1/chat/completions', anthropic: '/v1/messages', models: '/v1/models' },
+    }, null, 2);
+}

package/dist/server.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 本地反代 HTTP 服务骨架。
+ *
+ * 职责边界（刻意收窄）：只做「收请求 → 交给适配器 → 把 SSE 流原样吐回」。
+ * 协议翻译、凭证、模型清单全在**适配器**里 —— core 不含任何上游知识，
+ * 所以两家适配器共用这一个服务实现，改一处两家都受益。
+ *
+ * 暴露的端点（与 OpenAI / Anthropic 客户端约定一致）：
+ *   POST /v1/chat/completions   OpenAI 兼容聊天（Cursor / Cherry Studio 等）
+ *   POST /v1/messages           Anthropic 兼容聊天（Claude Code 等）
+ *   GET  /v1/models             模型列表（OpenAI 形状）
+ *   GET  /healthz               健康检查（无鉴权，供探活）
+ *
+ * 安全默认：只监听回环地址；`--host 0.0.0.0` 需显式指定并打印警告。
+ */
+import type { Adapter } from './types.js';
+export interface ServeOptions {
+    host: string;
+    port: number;
+    /** 入站密钥；请求需带 `Authorization: Bearer <key>` 或 `x-api-key: <key>`。 */
+    apiKey: string;
+    verbose?: boolean;
+    /** 请求日志（默认 stdout）。 */
+    log?: (line: string) => void;
+}
+export interface RunningServer {
+    port: number;
+    /** 关停（等现有连接结束）。 */
+    close(): Promise<void>;
+}
+/**
+ * 启动服务。适配器提供协议侧的一切（凭证、翻译、流）。
+ */
+export declare function startServer(adapter: Adapter, opts: ServeOptions): Promise<RunningServer>;

package/dist/server.js

@@ -0,0 +1,160 @@
+/**
+ * 本地反代 HTTP 服务骨架。
+ *
+ * 职责边界（刻意收窄）：只做「收请求 → 交给适配器 → 把 SSE 流原样吐回」。
+ * 协议翻译、凭证、模型清单全在**适配器**里 —— core 不含任何上游知识，
+ * 所以两家适配器共用这一个服务实现，改一处两家都受益。
+ *
+ * 暴露的端点（与 OpenAI / Anthropic 客户端约定一致）：
+ *   POST /v1/chat/completions   OpenAI 兼容聊天（Cursor / Cherry Studio 等）
+ *   POST /v1/messages           Anthropic 兼容聊天（Claude Code 等）
+ *   GET  /v1/models             模型列表（OpenAI 形状）
+ *   GET  /healthz               健康检查（无鉴权，供探活）
+ *
+ * 安全默认：只监听回环地址；`--host 0.0.0.0` 需显式指定并打印警告。
+ */
+import { createServer } from 'node:http';
+import { aggregateSseToJson } from './aggregate.js';
+/** 从入站头里取密钥（OpenAI 用 Bearer，Anthropic 用 x-api-key）。 */
+function extractKey(req) {
+    const auth = req.headers['authorization'];
+    if (typeof auth === 'string' && auth.toLowerCase().startsWith('bearer ')) {
+        return auth.slice(7).trim();
+    }
+    const apiKey = req.headers['x-api-key'];
+    if (typeof apiKey === 'string' && apiKey.trim())
+        return apiKey.trim();
+    return null;
+}
+async function readJsonBody(req, limitBytes = 8 * 1024 * 1024) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buf = chunk;
+        size += buf.length;
+        if (size > limitBytes)
+            throw new Error('请求体过大');
+        chunks.push(buf);
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    return text ? JSON.parse(text) : {};
+}
+function sendJson(res, status, body) {
+    const text = JSON.stringify(body);
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'content-length': Buffer.byteLength(text) });
+    res.end(text);
+}
+/** OpenAI 形状的错误体（客户端普遍认这个）。 */
+function sendError(res, status, message, code = 'upstream_error') {
+    sendJson(res, status, { error: { message, type: 'waygate_error', code } });
+}
+/**
+ * 启动服务。适配器提供协议侧的一切（凭证、翻译、流）。
+ */
+export function startServer(adapter, opts) {
+    const log = opts.log ?? ((line) => process.stdout.write(line + '\n'));
+    const server = createServer((req, res) => {
+        void handle(req, res).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            log(`[错误] ${message}`);
+            if (!res.headersSent)
+                sendError(res, 502, message);
+            else
+                res.end();
+        });
+    });
+    async function handle(req, res) {
+        const url = req.url ?? '/';
+        const path = url.split('?')[0] ?? '/';
+        /* 健康检查：无鉴权（探活用）。 */
+        if (path === '/healthz') {
+            sendJson(res, 200, { ok: true, service: adapter.command, upstream: adapter.upstreamLabel });
+            return;
+        }
+        /* 鉴权：其余端点都要密钥。 */
+        const provided = extractKey(req);
+        if (provided !== opts.apiKey) {
+            sendError(res, 401, '入站密钥缺失或不正确（Authorization: Bearer <key> 或 x-api-key）', 'invalid_api_key');
+            return;
+        }
+        if (path === '/v1/models' && req.method === 'GET') {
+            const models = await adapter.listModels();
+            sendJson(res, 200, {
+                object: 'list',
+                data: models.map((m) => ({ id: m.id, object: 'model', owned_by: adapter.command, created: 0 })),
+            });
+            return;
+        }
+        if ((path === '/v1/chat/completions' || path === '/v1/messages') && req.method === 'POST') {
+            const raw = (await readJsonBody(req));
+            if (!raw || typeof raw.model !== 'string' || !raw.model.trim()) {
+                sendError(res, 400, 'model 为必填项', 'invalid_request_error');
+                return;
+            }
+            if (!Array.isArray(raw.messages) || raw.messages.length === 0) {
+                sendError(res, 400, 'messages 为必填项且不能为空', 'invalid_request_error');
+                return;
+            }
+            const body = { ...raw, model: raw.model, messages: raw.messages };
+            const wantsStream = body.stream !== false; // OpenAI 惯例：缺省 = 流式
+            if (opts.verbose)
+                log(`[请求] ${adapter.command} model=${body.model} messages=${body.messages.length} 流=${wantsStream}`);
+            /* 客户端断连即中止上游（不留下孤儿请求）。 */
+            const ac = new AbortController();
+            req.on('close', () => ac.abort());
+            const result = await adapter.chat(body, ac.signal);
+            /* stream:false → 聚合为单个 JSON 返回（OpenAI 规范要求）；
+               stream:true（或缺省）→ SSE 原样透传。 */
+            if (!wantsStream) {
+                try {
+                    const json = await aggregateSseToJson(result.stream);
+                    sendJson(res, result.status, JSON.parse(json));
+                }
+                catch (err) {
+                    if (!res.headersSent)
+                        sendError(res, 502, `非流式聚合失败：${err.message}`);
+                    else
+                        res.end();
+                }
+                return;
+            }
+            res.writeHead(result.status, {
+                'content-type': 'text/event-stream; charset=utf-8',
+                'cache-control': 'no-cache',
+                connection: 'keep-alive',
+                'x-accel-buffering': 'no',
+            });
+            const reader = result.stream.getReader();
+            try {
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value)
+                        res.write(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+                res.end();
+            }
+            return;
+        }
+        sendError(res, 404, `未知端点 ${path}`, 'not_found');
+    }
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port, opts.host, () => {
+            const addr = server.address();
+            const port = typeof addr === 'object' && addr ? addr.port : opts.port;
+            resolve({
+                port,
+                close: () => new Promise((done) => {
+                    server.close(() => done());
+                    /* 已建的 keep-alive 连接不主动断，close 会等它们；给一个兜底超时。 */
+                    setTimeout(() => done(), 3000).unref?.();
+                }),
+            });
+        });
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * 共享类型（Waygate 家族）。
+ *
+ * 只放**跨仓库共用**的形状：聊天消息、上游凭证、模型条目、适配器契约。
+ * 各家的私有形状（COSY 会话、MiniMax refresh 响应等）留在各自仓库。
+ */
+/**
+ * 入站聊天消息 —— **保持 OpenAI 原始字段名**（snake_case）。
+ *
+ * 为什么不归一成 camelCase：两家适配器都要读客户端发来的原始形状
+ * （`tool_call_id` / `tool_calls` 等），归一反而要求适配器再做一层反查；
+ * 且客户端字段可能随版本增减，保留原始形状 + 宽松的可选字段最不容易漏。
+ */
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: unknown;
+    /** 工具结果消息关联的调用 id（OpenAI 原始字段名）。 */
+    tool_call_id?: string;
+    /** assistant 消息里的工具调用（OpenAI 原始形状）。 */
+    tool_calls?: Array<{
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }>;
+    [key: string]: unknown;
+}
+/** 入站请求体（两家共用的最小字段集；额外字段由各家适配器自行读取）。 */
+export interface ChatRequestBody {
+    model: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    [key: string]: unknown;
+}
+/** 模型条目：`id` 是路由键（客户端填的模型名），`displayName` 给人看。 */
+export interface ModelEntry {
+    id: string;
+    displayName?: string;
+    /** 上游标记（如计价徽标）；无则 null。 */
+    tag?: string | null;
+}
+/** 凭证就绪状态（doctor / 启动输出共用）。 */
+export interface CredentialStatus {
+    ok: boolean;
+    /** 人话描述（如「专用账号 A，access 有效至 2026-11-10」）。 */
+    detail: string;
+    /** 凭证来源文件路径（给用户排查用；不含令牌本体）。 */
+    source?: string;
+}
+/** 一次上游调用的结果：SSE 字节流（两家最终都归一到 OpenAI SSE 形状）。 */
+export interface UpstreamCallResult {
+    /** 响应体流（已是 OpenAI 兼容 SSE 形状，或原始裸流由 core 负责写出）。 */
+    stream: ReadableStream<Uint8Array>;
+    status: number;
+}
+/** 适配器契约：每家实现这一组钩子，core 负责 HTTP 服务与生命周期。 */
+export interface Adapter {
+    /** 命令名（如 'qoc' / 'mmcode'），用于错误信息与配置目录。 */
+    readonly command: string;
+    /** 展示名（如 'Qoder CN' / 'MiniMax Code'）。 */
+    readonly displayName: string;
+    /** 默认端口。 */
+    readonly defaultPort: number;
+    /** 人话的上游描述（启动输出用）。 */
+    readonly upstreamLabel: string;
+    /** 凭证是否就绪 + 人话状态。 */
+    credentialStatus(): Promise<CredentialStatus>;
+    /** 引导导入/刷新本机客户端登录态（`login` 子命令）。 */
+    login(): Promise<void>;
+    /** 列出模型（`models` 子命令 + 启动输出）。 */
+    listModels(): Promise<ModelEntry[]>;
+    /** 处理一次聊天请求，返回 OpenAI 兼容 SSE 流。 */
+    chat(body: ChatRequestBody, signal: AbortSignal): Promise<UpstreamCallResult>;
+    /** 可选：额外的自检项（如上游连通性）。 */
+    doctorChecks?(): Promise<Array<{
+        name: string;
+        ok: boolean;
+        detail: string;
+    }>>;
+    /** 可选：本家特有的子命令（如 MiniMax 的签到/积分）。core 负责解析与分发。 */
+    extraCommands?: ExtraCommand[];
+}
+/** 适配器自有的子命令（在 core 的通用子命令之外）。 */
+export interface ExtraCommand {
+    /** 子命令名（如 'checkin' / 'credits'）。 */
+    name: string;
+    /** 一句话说明（帮助与列表用）。 */
+    summary: string;
+    /** 用法行（帮助里显示的完整形态）。 */
+    usage: string;
+    /** 执行；`json` 为真时输出机器可读结果（返回的字符串直接打印）。 */
+    run(opts: {
+        json: boolean;
+        args: string[];
+    }): Promise<string>;
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * 共享类型（Waygate 家族）。
+ *
+ * 只放**跨仓库共用**的形状：聊天消息、上游凭证、模型条目、适配器契约。
+ * 各家的私有形状（COSY 会话、MiniMax refresh 响应等）留在各自仓库。
+ */
+export {};

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "waygate-core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Waygate 家族共享骨架：本地反代 HTTP 服务、入站密钥、CLI、自检",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.test.json",
+    "prepare": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}