@numa-tech/numa 1.11.14 → 1.12.2

package/README.md

@@ -9,6 +9,7 @@
 - 网页控制台提供身份概览、基础配置、命令发现和非交互命令执行；
 - 包含 Realm 角色、Client 角色和用户组的个人信息页；
 - 使用服务端托管的 Codex 账号启动官方 Codex CLI，客户端不保存 refresh token；
+- 通过平台授权代理发现、治理并安装私有 Nacos Skills 与 MCP Servers；
 - 通过领域化 `media` 命令安全调用平台托管的 TTS、视频、资产和素材库服务；
 - 兼容原有 stdio MCP 服务。
 
@@ -23,9 +24,10 @@ npm config set @numa-tech:registry=https://registry.npmjs.org/
 ```
 
 公司私有 registry 仍受支持，可通过 `numa config --set registryUrl=<url>` 或 shortcut
-的 `--registry-url <url>` 显式选择。发布人员使用 `npm run publish:all`，脚本默认先把
-patch 版本加一，再将同一 tarball 依次推送到公共 npm 和公司私有 registry；脚本会跳过
-已存在的同版本。若其中一个仓库失败，使用 `--resume` 以当前版本补推，不会再次修改版本号。
+的 `--registry-url <url>` 显式选择。发布人员先使用 `npm run release -- patch --tag=candidate`；脚本锁步更新
+所有 workspace 的版本与内部精确依赖，并按依赖顺序将每个包的同一份 tarball 依次推送到
+公共 npm 和公司私有 registry 的 `candidate` tag，不改动 `latest`。已存在且 integrity/tag 一致的目标会被跳过；部分失败时使用
+`npm run release:resume` 从持久化状态补推，不会再次修改版本或重新生成 tarball。
 可用 `NUMA_PUBLIC_NPM_REGISTRY`、`NUMA_PRIVATE_NPM_REGISTRY` 覆盖两个发布目标。旧版配置
 中作为默认值保存的私有 registry 会自动迁移到公共 npm；迁移后显式设置的私有地址会保留。
 
@@ -36,8 +38,9 @@ patch 版本加一，再将同一 tarball 依次推送到公共 npm 和公司私
 //packages.aliyun.com/60371955c4393f5ed3b7baa8/npm/npm-registry/:_authToken=${NPM_PRIVATE_TOKEN}
 ```
 
-脚本会在修改版本号之前运行公共 npm 的 `whoami` 和 `@numa-tech` scope 权限检查。使用验证器
-App 的本地交互发布会在公共 npm 推送前隐藏输入 6 位 OTP，并显式传给 `npm publish`；
+脚本会先检查 Git 工作区干净、当前分支与 upstream 完全同步，再于修改版本号之前检查两个
+registry 的身份以及公共 npm 的 `@tokensrc`、`@numa-tech` scope 权限。使用验证器 App 的
+本地交互发布会在公共 npm 推送前隐藏输入 6 位 OTP，并显式传给 `npm publish`；
 使用带 bypass 2FA 权限的 granular token 时直接回车即可。非交互环境可以临时提供
 `NUMA_PUBLIC_NPM_OTP`，更推荐使用 bypass 2FA granular token 或 npm trusted publishing。
 
@@ -47,31 +50,34 @@ App 的本地交互发布会在公共 npm 推送前隐藏输入 6 位 OTP，并
 npm login --registry=https://registry.npmjs.org/
 npm whoami --registry=https://registry.npmjs.org/
 npm org ls numa-tech --registry=https://registry.npmjs.org/
+npm org ls tokensrc --registry=https://registry.npmjs.org/
 ```
 
 双仓库发布命令：
 
 ```bash
-# 仅预览：1.11.9 -> 1.11.10，不修改文件、不访问 registry
-npm run publish:all -- --dry-run
+# 仅预览：1.12.0 -> 1.12.1，默认 candidate，不修改文件、不访问 registry
+npm run release -- patch --dry-run
 
-# 默认 patch：自动修改 package.json 和 package-lock.json，然后推送两个仓库
-npm run publish:all
+# 候选 patch：全量验证、双发到 candidate，成功后提交、打 tag 并原子推送
+npm run release -- patch --tag=candidate
 
-# minor / major / 指定完整版本
-npm run publish:all -- minor
-npm run publish:all -- major
-npm run publish:all -- 2.0.0
+# 线上验收通过后，显式把同一候选版本晋级为 latest
+npm run release:promote -- 1.12.1 --from-tag=candidate
 
-# 某个仓库失败后，用当前版本补推；不会再次升级版本
-npm run publish:resume
+# 候选 minor / 指定完整版本（也可显式附加 --tag=next）
+npm run release -- minor
+npm run release -- 2.0.0
 
-# 等价写法（注意中间必须有独立的 --）
-npm run publish:all -- --resume
+# 某个目标失败后恢复；查询两个 registry 并复用原 tarball/integrity
+npm run release:resume
 ```
 
-脚本不会自动创建 Git commit 或 tag；发布成功后应提交版本文件。可先运行
-`npm whoami --registry=<registry-url>` 分别检查两个仓库的发布身份。
+候选发布只有在全部包的两个 registry integrity 与 candidate tag 都校验成功后，脚本才会创建
+`chore(release): vX.Y.Z` commit、附注 tag，并以一次 atomic push 推送分支和 tag。部分失败
+不会 commit 或打 tag，也不会尝试回滚 npm 的不可变版本。晋级命令会先验证干净且同步的
+release commit/tag、两个 registry 的候选 tag 及跨 registry integrity，再幂等更新 `latest`；
+它不修改源码或 Git 历史。
 
 macOS / Windows 日常启动 Codex 的推荐方式：
 
@@ -106,6 +112,11 @@ npm link
 numa help
 ```
 
+仓库使用 npm workspaces 与 Turborepo。`npm run build`、`npm run typecheck`、`npm test`、
+`npm run pack:check` 会按 workspace 依赖图执行并使用本地缓存；CI 可运行
+`npm run check:affected` 只验证受变更影响的任务。跨包代码只能通过 package exports 导入，
+`npm run boundaries` 会拒绝直接引用其他 workspace 的 `src` 路径。
+
 ## 快速开始
 
 ```bash
@@ -154,6 +165,11 @@ numa config \
 | `numa request <path>` | 需登录 | 携带令牌调用平台 API |
 | `numa request <path> --require-role <role...>` | 需角色 | 调用前检查指定角色之一 |
 | `numa admin context` | 需角色 | 要求 `platform-admin` 或 `numa-admin` |
+| `numa registry instances list/create/update/delete` | 需登录 | 管理数据库中的 Nacos 实例和 OIDC 配置；写操作需要 Registry admin |
+| `numa registry namespaces list/resolve/check/create/update/delete` | 需登录 | 管理多实例 namespace 路由与跨集群默认项；写操作需要 Registry admin |
+| `numa registry skill list/inspect/install/upload/...` | 需登录 | 发现、安装和治理 Nacos Skills；发布类操作需要 Registry admin |
+| `numa registry mcp list/inspect/install/create/update/delete` | 需登录 | 发现、安装和维护 Nacos MCP Servers；写操作需要 Registry admin |
+| `numa registry tui` | 需登录 | 在终端交互浏览、安装和治理 Skill/MCP |
 | `numa media capabilities` | 需登录 | 查询媒体 API、Provider 和版本能力 |
 | `numa media tts submit` | 需登录 | 提交 TTS 异步任务 |
 | `numa media video submit` | 需登录 | 提交视频生成异步任务 |
@@ -193,6 +209,9 @@ CLI 的本地角色检查用于快速反馈和隐藏无权限入口，不能替
 - `output`：`text` 或 `json`；
 - `apiBaseUrl`：内部研发平台 API 根地址，默认
   `https://apps-gw-prd.mcisaas.com/mci-devops-platform`；
+- `profileUrl`：完整的公开 client-configuration URL；设置后各模块只使用该
+  profile 声明的 service 与 authority；
+- `profileId`：可选的 profile 标识锁定；远端返回其他标识时拒绝启用；
 - `registryUrl`：npm registry，默认公共 npm，也可配置公司私有 registry；
 - `checkUpdates`：是否检查 CLI 更新。
 
@@ -202,6 +221,7 @@ CLI 的本地角色检查用于快速反馈和隐藏无权限入口，不能替
 numa config --show
 numa config --show --json
 numa config --set output=json --set checkUpdates=false
+numa config --set profileUrl=https://apps-gw-prd.mcisaas.com/mci-devops-platform/public/v1/client-configurations/numa-realm
 numa config --reset
 ```
 
@@ -227,7 +247,10 @@ numa console --no-open
 numa login --no-console --no-config --json
 ```
 
-控制台展示当前身份、Realm/Client 角色、ChatGPT 账号、基础配置和机器可读命令目录。
+控制台展示当前身份、Realm/Client 角色、AI Registry、ChatGPT 账号、基础配置和机器可读命令目录。
+AI Registry 页按“namespace → Skill/MCP → 详情/动作”组织，支持搜索、详情、安装以及 Skill
+提交/发布/上下线。发布按钮是否可用只是界面提示，实际权限始终由平台 Keycloak Policy
+Enforcer 决定。
 ChatGPT 账号页先读取 `codex-multi-auth` 的本地账号与额度缓存并立即展示，再使用当前
 Keycloak 会话连接平台补充当前用户可用账号、剩余 limit 和同步状态。平台不可用时页面
 保留本地结果并明确显示“远程同步失败”，不会把 access token 或 refresh token 返回给页面。
@@ -242,6 +265,132 @@ JSON argv 调用同一版 CLI，不经过 shell，并自动要求结构化 `--js
 CSP。OIDC access/refresh token 始终保留在 CLI 进程及私有缓存中，不会返回给浏览器脚本；
 实际平台请求仍由服务端 Keycloak 授权决定。
 
+## 私有 Nacos AI Registry
+
+`numa registry` 对接 `mci-devops-platform` 的 `/api/v1/ai-registry` 类型化 API。客户端只携带
+当前用户 Keycloak Bearer Token；平台从自己的数据库解析 Nacos 实例、namespace 和该实例的
+OIDC client-credentials，再访问目标 Nacos。Nacos token、OIDC client secret 和 endpoint
+credential 不写入 Numa 配置，也不由读取 API 返回。
+
+权限契约：
+
+- `mci-devops-platform-ai-registry-reader`：`view`，可列出、检查、下载和安装；
+- `mci-devops-platform-ai-registry-admin`：`view` + `edit`，作为操作管理员管理实例、namespace、Skill 和 MCP；
+- 平台 operations admin 同时拥有 `view` + `edit`。
+
+Nacos 的 `baseUrl`、token URI、client ID、client secret 和 scope 全部按实例保存在
+`mci-devops-platform` 数据库。client secret 使用 AES-256-GCM 密文存储，读取接口只返回
+`credentialConfigured`，不会返回明文或密文。平台部署只需从 Secret/KMS 注入数据库密文的
+主密钥环 `AI_REGISTRY_SECRET_ENCRYPTION_KEYS` 与当前 key ID
+`AI_REGISTRY_SECRET_CURRENT_KEY_ID`；这两项是密钥管理材料，不是某个 Nacos 实例的配置。
+密钥环格式为逗号分隔的 `keyId=Base64(32-byte-key)`；轮换时先加入新 key 并切换当前 key ID，
+旧 key 必须保留到相关实例 secret 完成重写。
+SSRF 安全策略仍由 `AI_REGISTRY_ALLOWED_UPSTREAM_HOSTS`、
+`AI_REGISTRY_ALLOWED_TOKEN_HOSTS` 控制，allow-list 为空时 fail closed；HTTP 只可通过
+`AI_REGISTRY_ALLOW_HTTP=true` 用于开发环境。
+
+Nacos 实例文件示例（`clientSecret` 仅写入）：
+
+```json
+{
+  "code": "cluster-a",
+  "displayName": "Nacos Cluster A",
+  "baseUrl": "https://nacos.internal.example:8848",
+  "authenticationType": "OIDC_CLIENT_CREDENTIALS",
+  "tokenUri": "https://sso.internal.example/realms/mci/protocol/openid-connect/token",
+  "clientId": "nacos-registry-broker",
+  "clientSecret": "write-only-secret",
+  "scope": "openid",
+  "description": "A 集群",
+  "status": "ACTIVE"
+}
+```
+
+`instances update` 必须带列表结果中的当前 `version`，用于乐观锁保护；省略 `clientSecret`
+表示保留已有密文。建议让包含明文 secret 的输入文件仅对当前用户可读，并在写入后安全删除。
+
+namespace 文件示例：
+
+```json
+{
+  "namespaceKey": "team-ai",
+  "namespaceId": "upstream-namespace-id",
+  "displayName": "Team AI Registry",
+  "description": "面向客户端的稳定 namespace",
+  "isDefault": true,
+  "status": "ACTIVE"
+}
+```
+
+`namespaceKey` 是客户端使用的稳定名称，`namespaceId` 是该 Nacos 实例中的真实 ID。同一个
+`namespaceKey` 可以存在于多个实例；其中最多一个 ACTIVE 路由可设为 `isDefault=true`。
+客户端只传 `--namespace team-ai` 时，平台会选择唯一匹配项或默认项；同名且没有默认项时返回
+`AI_REGISTRY_NAMESPACE_AMBIGUOUS`，此时必须加 `--instance cluster-b` 消歧。
+
+V34 会把旧服务行拆成实例和 namespace，但旧 `credentialRef` 无法自动转换为数据库密文，
+所以迁移后的实例会先置为 `DISABLED`。管理员写入完整 OIDC 配置和 `clientSecret` 后再启用；
+跨集群重复的旧 namespace 不会自动猜测默认项。
+
+先发现实例和 namespace，再通过 namespace 操作资源：
+
+```bash
+numa registry instances list --json
+numa registry namespaces list --namespace team-ai --json
+numa registry namespaces resolve team-ai --json
+numa registry namespaces check team-ai --json
+
+numa registry skill list --namespace team-ai --search deploy --json
+numa registry skill inspect release-helper --namespace team-ai --json
+numa registry skill install release-helper \
+  --namespace team-ai --agent cursor --scope project --label latest --json
+
+numa registry mcp list --namespace team-ai --json
+numa registry mcp inspect internal-docs --namespace team-ai --json
+numa registry mcp install internal-docs \
+  --namespace team-ai --instance cluster-b --agent claude --scope project --json
+
+# 也可使用终端交互界面
+numa registry tui
+```
+
+Skill 发布生命周期：
+
+```bash
+numa registry skill upload ./release-helper.zip \
+  --namespace team-ai --target-version 1.0.0 --json
+numa registry skill submit release-helper --namespace team-ai --json
+numa registry skill publish release-helper \
+  --namespace team-ai --version 1.0.0 --json
+numa registry skill online release-helper --namespace team-ai --json
+numa registry skill scope release-helper PRIVATE --namespace team-ai --json
+numa registry skill tags release-helper deploy java --namespace team-ai --json
+```
+
+远端删除必须带 `--yes`。本地同名 Skill/MCP 默认拒绝覆盖；用户明确同意后才使用
+`--force`，支持原子替换的适配器会先保留时间戳备份。Skill 下载必须通过平台返回的
+SHA-256 校验，ZIP 在解压前会检查根 `SKILL.md`、路径穿越、符号链接、重复路径、文件数和
+膨胀大小。MCP 定义中的敏感 env/header 只能使用 `${ENV_VAR}` 占位符，不能携带明文密钥。
+
+### 客户端安装适配
+
+| 客户端 | Skill | MCP Server |
+| --- | --- | --- |
+| ChatGPT / Codex coding workspace | `.codex/skills` | ChatGPT 仅接受远程 HTTPS MCP App；Numa 返回 Developer mode/App 创建指引，不会冒充修改工作区设置 |
+| Codex | `.codex/skills` | 调用官方 `codex mcp add`，仅 user scope |
+| Claude | `.claude/skills` | 项目 `.mcp.json`；user scope 使用 `~/.claude.json` |
+| Cursor | `.cursor/skills` | `.cursor/mcp.json` |
+| WorkBuddy | `.workbuddy/skills` | `.workbuddy/mcp.json`；目录可通过 custom adapter 调整 |
+| OpenClaw | `.openclaw/skills` | 调用官方 `openclaw mcp set`，仅 user scope |
+
+ChatGPT 本身不能直接连接本地 stdio MCP。Numa 对 `--agent chatgpt` 只为远程 HTTPS endpoint
+生成受控安装指引；私网或本机 MCP 需要先发布为远程服务，或使用 ChatGPT 支持的 Secure
+MCP Tunnel。ChatGPT workspace 还需管理员按其计划和 RBAC 开启 Developer mode。
+
+仓库内置的自用 Skill 位于 `skills/numa-ai-registry/SKILL.md`，并随 npm 包发布。它指导 AI
+按“认证 → 服务解析 → inspect → 安装/治理 → 复查”的顺序使用 Registry，同时明确禁止索取
+Nacos token、绕过 403 或未经确认覆盖本地配置。对应场景评测在
+`skills/numa-ai-registry/evals/evals.json`。
+
 ## 平台媒体服务
 
 自 1.8.0 起，`numa media` 通过当前 Keycloak 会话调用 `/api/v1/media`。第三方
@@ -323,11 +472,11 @@ Numa 会清理项目更名前旧版本写入的自定义 `model_provider = "mcex
 
 自 1.7.0 起，职责进一步收敛：numa 负责服务端账号分发、选择和短效凭据同步，`codex-multi-auth/cli` 负责把凭据应用到官方文件登录并返回脱敏状态。消费端不会调用 `codex-multi-auth` 的 OAuth 登录、本地账号池切换或 refresh token 刷新功能；真实 refresh token 仍只存在于服务端。升级期间 2.8.x 保留兼容写入路径，安装 `codex-multi-auth` 2.9.0 及以上后自动使用新的公共接口。
 
-默认连接生产网关；也可通过以下任一种方式显式覆盖：
+默认连接已授权的 Active 集成服务；也可通过以下任一种方式显式覆盖：
 
 ```bash
-numa codex list --server https://apps-gw-prd.mcisaas.com/mci-devops-platform/api
-export NUMA_CODEX_SERVICE_URL=https://apps-gw-prd.mcisaas.com/mci-devops-platform/api
+numa codex list --server https://mail.tokensource.top --tenant-id numa-realm
+export NUMA_CODEX_SERVICE_URL=https://mail.tokensource.top/api
 numa config --set apiBaseUrl=https://apps-gw-prd.mcisaas.com/mci-devops-platform
 ```
 
@@ -410,14 +559,15 @@ npx -y --prefer-online --registry=https://registry.npmjs.org/ @numa-tech/numa@la
 refresh token 时整批终止，避免服务端形成不完整快照。令牌只通过带 Keycloak Bearer
 认证的 HTTPS 请求发送，不写入 CLI 输出。
 
-`@numa-tech/numa` 直接依赖官方 `@openai/codex`，因此发布到 npm 后，新主机可以用一条命令安装并启动：
+`@numa-tech/numa` 精确依赖同版本的 `@tokensrc/codex`；该模块封装官方
+`@openai/codex` runtime，因此发布到 npm 后，新主机仍可用一条命令安装并启动：
 
 ```bash
 npx -y --prefer-online --registry=https://registry.npmjs.org/ @numa-tech/numa@latest codex run --server https://platform.example/api
 ```
 
 启动时会先运行 `codex --version` 做健康检查，依次使用 `NUMA_CODEX_BIN` 指定的入口、
-PATH 中已安装且可用的 Codex CLI、最后才使用 `@numa-tech/numa` 包内版本。这样已全局安装
+PATH 中已安装且可用的 Codex CLI、最后才使用 `@tokensrc/codex` 依赖的包内版本。这样已全局安装
 Codex 的主机不会受包内平台可选依赖缺失影响；外部版本不可用时会自动回退。设置
 `NUMA_USE_BUNDLED_CODEX=1` 可跳过 PATH 探测并强制使用包内版本。
 
@@ -541,6 +691,28 @@ http://localhost:8765
 
 如需长期会话，还要允许 `offline_access`。
 
+Numa 主 CLI 与可独立运行的 `@tokensrc/codex` 通过
+`@numa-tech/cli-auth` 共用同一套 OIDC discovery、PKCE、私有缓存和 refresh
+token 轮换实现。该共享包只负责认证会话；租户角色和业务权限仍由各资源服务校验，CLI
+中的角色展示或预检查不能替代服务端授权。
+
+### 登录失效恢复
+
+访问令牌到期后，CLI 会在本地令牌缓存上加跨进程锁，再重新读取缓存并执行 refresh
+grant。多个 CLI 进程同时刷新时只有一个进程使用当前 refresh token，其他进程复用已经
+写入的新凭据。刷新成功后先原子保存新的 refresh token，再进行非关键的用户资料读取。
+
+如果身份服务明确返回 `invalid_grant`（包括 refresh token 已过期、撤销或超过最大复用
+次数），CLI 会将其分类为 `login_required`，而不是账号服务不可用：
+
+- 交互式 `numa codex` 命令会询问是否打开浏览器重新登录；确认后仅重试原命令一次；
+- 文本模式会给出 `numa login --no-console --no-config`；
+- JSON 模式在 `error.recovery_command` 返回同一恢复命令并使用退出码 `3`；
+- 身份服务网络错误或 5xx 不会删除仍可能恢复的本地会话，也不会误触发重新登录。
+
+独立 `tokensrc-codex` 遇到同类错误时返回 `login_required` 并提示运行
+`tokensrc-codex login`。重新登录和首次重试都不会再次强制刷新刚签发的会话。
+
 ### 认证环境变量
 
 | 变量 | 默认值 | 用途 |

package/dist/ai-registry/client.d.ts

@@ -0,0 +1,65 @@
+import type { AuthConfig } from "../config.js";
+import { type KeycloakTokenProvider } from "../oauth.js";
+import { type JsonObject, type RegistryInstance, type RegistryNamespace } from "./schemas.js";
+export interface AiRegistryClientDependencies {
+    fetch?: typeof fetch;
+    tokenProvider?: KeycloakTokenProvider;
+}
+export interface SkillDownload {
+    bytes: Buffer;
+    fileName: string;
+    sha256: string;
+}
+export declare class AiRegistryClient {
+    private readonly config;
+    private readonly fetchImpl;
+    private readonly tokenProvider;
+    constructor(config: AuthConfig, dependencies?: AiRegistryClientDependencies);
+    private authenticatedFetch;
+    private json;
+    listInstances(): Promise<RegistryInstance[]>;
+    createInstance(input: JsonObject): Promise<RegistryInstance>;
+    updateInstance(instanceId: number, input: JsonObject): Promise<RegistryInstance>;
+    deleteInstance(instanceId: number): Promise<void>;
+    listNamespaces(options?: {
+        instance?: string;
+        namespace?: string;
+    }): Promise<RegistryNamespace[]>;
+    resolveNamespace(namespace: string, instance?: string): Promise<RegistryNamespace>;
+    createNamespace(instanceId: number, input: JsonObject): Promise<RegistryNamespace>;
+    updateNamespace(namespaceId: number, input: JsonObject): Promise<RegistryNamespace>;
+    deleteNamespace(namespaceId: number): Promise<void>;
+    checkNamespace(namespaceId: number): Promise<JsonObject>;
+    listSkills(namespaceId: number, options?: {
+        search?: string;
+        skillName?: string;
+        scope?: "PUBLIC" | "PRIVATE";
+        pageNo?: number;
+        pageSize?: number;
+    }): Promise<JsonObject>;
+    getSkill(namespaceId: number, skillName: string): Promise<JsonObject>;
+    downloadSkill(namespaceId: number, skillName: string, options?: {
+        version?: string;
+        label?: string;
+    }): Promise<SkillDownload>;
+    uploadSkill(namespaceId: number, filePath: string, options?: {
+        overwrite?: boolean;
+        targetVersion?: string;
+        commitMsg?: string;
+        uploadAction?: string;
+    }): Promise<unknown>;
+    skillAction(namespaceId: number, skillName: string, action: "submit" | "publish" | "online" | "offline" | "scope" | "biz-tags" | "delete", body?: Record<string, unknown>): Promise<unknown>;
+    listMcpServers(namespaceId: number, options?: {
+        search?: string;
+        mcpName?: string;
+        pageNo?: number;
+        pageSize?: number;
+    }): Promise<JsonObject>;
+    getMcpServer(namespaceId: number, mcpName: string, version?: string): Promise<JsonObject>;
+    createMcpServer(namespaceId: number, specification: JsonObject): Promise<unknown>;
+    updateMcpServer(namespaceId: number, mcpName: string, specification: JsonObject): Promise<unknown>;
+    deleteMcpServer(namespaceId: number, mcpName: string, version?: string): Promise<unknown>;
+    private object;
+    private instanceResponse;
+    private namespaceResponse;
+}

package/dist/ai-registry/client.js

@@ -0,0 +1,260 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { resolveBackendUrl } from "../backend.js";
+import { ensureAccessToken, fetchWithKeycloakIdentity } from "../oauth.js";
+import { AiRegistryError, redactRegistryText } from "./errors.js";
+import { ApiErrorSchema, JsonObjectSchema, RegistryInstancesSchema, RegistryNamespacesSchema } from "./schemas.js";
+const API_ROOT = "/api/v1/ai-registry";
+const MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024;
+const MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
+async function responseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function boundedResponseBytes(response, maximum) {
+    if (!response.body)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > maximum) {
+                await reader.cancel().catch(() => undefined);
+                throw new AiRegistryError("Skill archive exceeds 50 MiB.", "ai_registry_download_too_large");
+            }
+            chunks.push(Buffer.from(value));
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, size);
+}
+function apiError(response, body) {
+    const parsed = ApiErrorSchema.safeParse(body);
+    const message = parsed.success
+        ? parsed.data.message ?? response.statusText
+        : typeof body === "string"
+            ? body
+            : response.statusText;
+    return new AiRegistryError(`AI Registry HTTP ${response.status}: ${redactRegistryText(message || "request failed")}`, parsed.success ? parsed.data.code ?? "ai_registry_api_error" : "ai_registry_api_error", response.status, parsed.success ? parsed.data.requestId : response.headers.get("x-request-id") ?? undefined);
+}
+function safeIdentifier(value, label) {
+    if (!value || value.length > 160 || /[\\/?#%\u0000-\u001f\u007f]/u.test(value)) {
+        throw new AiRegistryError(`${label} is invalid.`, "ai_registry_input_invalid");
+    }
+    return value;
+}
+export class AiRegistryClient {
+    config;
+    fetchImpl;
+    tokenProvider;
+    constructor(config, dependencies = {}) {
+        this.config = config;
+        this.fetchImpl = dependencies.fetch ?? fetch;
+        this.tokenProvider = dependencies.tokenProvider ?? ensureAccessToken;
+    }
+    async authenticatedFetch(path, init = {}) {
+        const url = resolveBackendUrl(this.config, { method: "GET", path });
+        const headers = new Headers(init.headers);
+        if (!headers.has("Accept"))
+            headers.set("Accept", "application/json");
+        return fetchWithKeycloakIdentity(this.config, url, () => ({ ...init, headers }), { fetch: this.fetchImpl, tokenProvider: this.tokenProvider });
+    }
+    async json(path, init = {}) {
+        const headers = new Headers(init.headers);
+        if (init.body != null && typeof init.body === "string")
+            headers.set("Content-Type", "application/json");
+        const response = await this.authenticatedFetch(path, { ...init, headers });
+        const body = await responseBody(response);
+        if (!response.ok)
+            throw apiError(response, body);
+        return body;
+    }
+    async listInstances() {
+        const parsed = RegistryInstancesSchema.safeParse(await this.json(`${API_ROOT}/instances`));
+        if (!parsed.success) {
+            throw new AiRegistryError(`Instance response is invalid: ${parsed.error.message}`, "ai_registry_invalid_response");
+        }
+        return parsed.data;
+    }
+    async createInstance(input) {
+        return this.instanceResponse(await this.json(`${API_ROOT}/instances`, { method: "POST", body: JSON.stringify(input) }));
+    }
+    async updateInstance(instanceId, input) {
+        return this.instanceResponse(await this.json(`${API_ROOT}/instances/${instanceId}`, { method: "PUT", body: JSON.stringify(input) }));
+    }
+    async deleteInstance(instanceId) {
+        await this.json(`${API_ROOT}/instances/${instanceId}`, { method: "DELETE" });
+    }
+    async listNamespaces(options = {}) {
+        const query = new URLSearchParams();
+        if (options.instance)
+            query.set("instance", safeIdentifier(options.instance, "instance"));
+        if (options.namespace)
+            query.set("namespace", safeIdentifier(options.namespace, "namespace"));
+        const suffix = query.size ? `?${query}` : "";
+        const parsed = RegistryNamespacesSchema.safeParse(await this.json(`${API_ROOT}/namespaces${suffix}`));
+        if (!parsed.success) {
+            throw new AiRegistryError(`Namespace response is invalid: ${parsed.error.message}`, "ai_registry_invalid_response");
+        }
+        return parsed.data;
+    }
+    async resolveNamespace(namespace, instance) {
+        const query = new URLSearchParams({ namespace: safeIdentifier(namespace, "namespace") });
+        if (instance)
+            query.set("instance", safeIdentifier(instance, "instance"));
+        return this.namespaceResponse(await this.json(`${API_ROOT}/namespaces/resolve?${query}`));
+    }
+    async createNamespace(instanceId, input) {
+        return this.namespaceResponse(await this.json(`${API_ROOT}/instances/${instanceId}/namespaces`, {
+            method: "POST",
+            body: JSON.stringify(input)
+        }));
+    }
+    async updateNamespace(namespaceId, input) {
+        return this.namespaceResponse(await this.json(`${API_ROOT}/namespaces/${namespaceId}`, {
+            method: "PUT",
+            body: JSON.stringify(input)
+        }));
+    }
+    async deleteNamespace(namespaceId) {
+        await this.json(`${API_ROOT}/namespaces/${namespaceId}`, { method: "DELETE" });
+    }
+    async checkNamespace(namespaceId) {
+        return this.object(`${API_ROOT}/namespaces/${namespaceId}/health`);
+    }
+    async listSkills(namespaceId, options = {}) {
+        const query = new URLSearchParams();
+        if (options.search)
+            query.set("search", options.search);
+        if (options.skillName)
+            query.set("skillName", safeIdentifier(options.skillName, "skillName"));
+        if (options.scope)
+            query.set("scope", options.scope);
+        query.set("pageNo", String(options.pageNo ?? 1));
+        query.set("pageSize", String(options.pageSize ?? 20));
+        return this.object(`${API_ROOT}/namespaces/${namespaceId}/skills?${query}`);
+    }
+    async getSkill(namespaceId, skillName) {
+        return this.object(`${API_ROOT}/namespaces/${namespaceId}/skills/${encodeURIComponent(safeIdentifier(skillName, "skillName"))}`);
+    }
+    async downloadSkill(namespaceId, skillName, options = {}) {
+        if (options.version && options.label) {
+            throw new AiRegistryError("Specify version or label, not both.", "ai_registry_input_invalid");
+        }
+        const query = new URLSearchParams();
+        if (options.version)
+            query.set("version", options.version);
+        if (options.label)
+            query.set("label", options.label);
+        const suffix = query.size ? `?${query}` : "";
+        const response = await this.authenticatedFetch(`${API_ROOT}/namespaces/${namespaceId}/skills/${encodeURIComponent(safeIdentifier(skillName, "skillName"))}/download${suffix}`, { headers: { Accept: "application/zip" } });
+        if (!response.ok)
+            throw apiError(response, await responseBody(response));
+        const lengthHeader = response.headers.get("content-length");
+        const declaredLength = lengthHeader == null ? undefined : Number(lengthHeader);
+        if (declaredLength != null && (!Number.isSafeInteger(declaredLength) || declaredLength < 0 || declaredLength > MAX_DOWNLOAD_BYTES)) {
+            throw new AiRegistryError("Skill archive exceeds 50 MiB.", "ai_registry_download_too_large");
+        }
+        const bytes = await boundedResponseBytes(response, MAX_DOWNLOAD_BYTES);
+        const sha256 = createHash("sha256").update(bytes).digest("hex");
+        const expected = response.headers.get("x-content-sha256")?.toLowerCase();
+        if (!expected || !/^[a-f0-9]{64}$/u.test(expected) || expected !== sha256) {
+            throw new AiRegistryError("Skill archive SHA-256 verification failed.", "ai_registry_integrity_failed");
+        }
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const matched = /filename="?([^";]+)"?/iu.exec(disposition)?.[1];
+        const fileName = matched && matched === basename(matched) ? matched : `${safeIdentifier(skillName, "skillName")}.zip`;
+        return { bytes, fileName, sha256 };
+    }
+    async uploadSkill(namespaceId, filePath, options = {}) {
+        const info = await stat(filePath);
+        if (!info.isFile() || info.size < 1 || info.size > MAX_UPLOAD_BYTES) {
+            throw new AiRegistryError("Skill ZIP must be a file between 1 byte and 20 MiB.", "ai_registry_upload_invalid");
+        }
+        const bytes = await readFile(filePath);
+        const form = new FormData();
+        form.append("file", new Blob([bytes], { type: "application/zip" }), basename(filePath));
+        const query = new URLSearchParams({ overwrite: String(Boolean(options.overwrite)) });
+        if (options.targetVersion)
+            query.set("targetVersion", options.targetVersion);
+        if (options.commitMsg)
+            query.set("commitMsg", options.commitMsg);
+        if (options.uploadAction)
+            query.set("uploadAction", options.uploadAction);
+        return this.json(`${API_ROOT}/namespaces/${namespaceId}/skills/upload?${query}`, { method: "POST", body: form });
+    }
+    async skillAction(namespaceId, skillName, action, body = {}) {
+        const path = `${API_ROOT}/namespaces/${namespaceId}/skills/${encodeURIComponent(safeIdentifier(skillName, "skillName"))}`;
+        if (action === "delete")
+            return this.json(path, { method: "DELETE" });
+        const method = action === "scope" || action === "biz-tags" ? "PUT" : "POST";
+        return this.json(`${path}/${action}`, { method, body: JSON.stringify(body) });
+    }
+    async listMcpServers(namespaceId, options = {}) {
+        const query = new URLSearchParams();
+        if (options.search)
+            query.set("search", options.search);
+        if (options.mcpName)
+            query.set("mcpName", safeIdentifier(options.mcpName, "mcpName"));
+        query.set("pageNo", String(options.pageNo ?? 1));
+        query.set("pageSize", String(options.pageSize ?? 20));
+        return this.object(`${API_ROOT}/namespaces/${namespaceId}/mcp-servers?${query}`);
+    }
+    async getMcpServer(namespaceId, mcpName, version) {
+        const query = new URLSearchParams();
+        if (version)
+            query.set("version", version);
+        const suffix = query.size ? `?${query}` : "";
+        return this.object(`${API_ROOT}/namespaces/${namespaceId}/mcp-servers/${encodeURIComponent(safeIdentifier(mcpName, "mcpName"))}${suffix}`);
+    }
+    async createMcpServer(namespaceId, specification) {
+        return this.json(`${API_ROOT}/namespaces/${namespaceId}/mcp-servers`, { method: "POST", body: JSON.stringify(specification) });
+    }
+    async updateMcpServer(namespaceId, mcpName, specification) {
+        return this.json(`${API_ROOT}/namespaces/${namespaceId}/mcp-servers/${encodeURIComponent(safeIdentifier(mcpName, "mcpName"))}`, { method: "PUT", body: JSON.stringify(specification) });
+    }
+    async deleteMcpServer(namespaceId, mcpName, version) {
+        const query = new URLSearchParams();
+        if (version)
+            query.set("version", version);
+        const suffix = query.size ? `?${query}` : "";
+        return this.json(`${API_ROOT}/namespaces/${namespaceId}/mcp-servers/${encodeURIComponent(safeIdentifier(mcpName, "mcpName"))}${suffix}`, { method: "DELETE" });
+    }
+    async object(path) {
+        const parsed = JsonObjectSchema.safeParse(await this.json(path));
+        if (!parsed.success) {
+            throw new AiRegistryError(`Registry response is invalid: ${parsed.error.message}`, "ai_registry_invalid_response");
+        }
+        return parsed.data;
+    }
+    instanceResponse(value) {
+        const parsed = RegistryInstancesSchema.element.safeParse(value);
+        if (!parsed.success) {
+            throw new AiRegistryError(`Instance response is invalid: ${parsed.error.message}`, "ai_registry_invalid_response");
+        }
+        return parsed.data;
+    }
+    namespaceResponse(value) {
+        const parsed = RegistryNamespacesSchema.element.safeParse(value);
+        if (!parsed.success) {
+            throw new AiRegistryError(`Namespace response is invalid: ${parsed.error.message}`, "ai_registry_invalid_response");
+        }
+        return parsed.data;
+    }
+}
+//# sourceMappingURL=client.js.map