@nextxai/cli 0.1.1 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.1
+
+- Help examples (`keys create --scopes`, `ci policy`) show permission codes of your own product.
+- Release: a version already on npm is skipped instead of failing the release.
+
+## 0.3.0
+
+- `ci policy request|list|show|revoke|kinds`: pre-approval policies let a CI repository write on its own — chosen write permissions, a total row ceiling (up to 1000), at most 30 days. Anyone requests; an API-key manager approves (or `--approve` if you are one). A CI session cannot request, approve or revoke a policy.
+- In CI (`login --ci`, no terminal) with `--mode auto`, proposals are sent for confirmation and the server applies them only within an active policy; otherwise they stay a proposal (exit code 7). `-p --json` reports `proposals[0].applied` and exits 0 when written.
+- A CI session calls the API directly with the permissions of the person who added the repository; it cannot create API keys, CI trusts, policies, sessions or other long-lived access.
+- `ci trust add` no longer takes write options — use `ci policy request`. Policy ids are shown by their last 8 characters.
+
+## 0.2.0
+
+- `--model`: answer with your own model on your machine — Claude, Gemini, GPT, Grok or Ollama — using your workspace tools over MCP. Writes still only create a proposal you confirm. `model add|list|remove|default`, and `/model` switches inside the chat.
+- AI tool access (`tools`, `--model`) now works in workspaces that allow verified AI apps only (the default): the CLI identifies itself with a client metadata document on the developer portal instead of registering a new client.
+- `login --ci`: GitHub Actions / GitLab CI sign in with their OIDC token, no secret. Admins allow a repository with `ci trust add`.
+
 ## 0.1.1
 
 - x64 builds (Intel Mac, Linux, Windows) now target every x64 CPU, including older Intel Macs without AVX2.
@@ -9,7 +27,7 @@
 
 First release.
 
-- Chat with the assistant in the terminal (`nextx`), with slash commands, file attachments, permission modes and confirmed writes.
+- Chat with the assistant in the terminal, with slash commands, file attachments, permission modes and confirmed writes.
 - Login: browser (PKCE), QR via the mobile app, device code, API key, CI OIDC.
 - `-p` / `--json` / `--output-format stream-json` for scripts and agents.
 - `tools`, `api`, `keys`, `webhooks` (including `listen --forward-to` and `verify`), `mcp install|serve`, `doctor`, `completion`, `update`, `init`.

package/dist/ai/client.js

@@ -8,16 +8,36 @@ import { CliError, Exit } from "../core/errors.js";
 import { tr } from "../core/i18n.js";
 import { brand } from "../core/brand.js";
 const BASE = "/operator/widget/support";
-export const openConversation = (forceNew) => post(`${BASE}/init`, { forceNew });
-export const listConversations = (limit = 30) => get(`${BASE}/conversations`, { query: { limit } });
-export const renameConversation = (id, title) => patch(`${BASE}/conversations/${id}/title`, { title });
-export const pinConversation = (id, pinned) => put(`${BASE}/conversations/${id}/pin`, { pinned });
-export const deleteConversation = (id) => del(`${BASE}/conversations/${id}`);
-export const history = (sessionId) => get(`${BASE}/history`, { query: { sessionId } });
-export const feedback = (messageId, helpful) => post(`${BASE}/messages/${messageId}/feedback`, { helpful });
-export const escalate = (sessionId, topic) => post(`${BASE}/escalate`, { sessionId, topic });
-export const usage = () => get(`${BASE}/usage`);
-export const confirmAction = (sessionId, a) => post(`${BASE}/${sessionId}/confirm-action`, { kind: a.kind, payloadJson: a.payloadJson, nonce: a.nonce });
+export const openConversation = (forceNew) => {
+    return post(`${BASE}/init`, { forceNew });
+};
+export const listConversations = (limit = 30) => {
+    return get(`${BASE}/conversations`, { query: { limit } });
+};
+export const renameConversation = (id, title) => {
+    return patch(`${BASE}/conversations/${id}/title`, { title });
+};
+export const pinConversation = (id, pinned) => {
+    return put(`${BASE}/conversations/${id}/pin`, { pinned });
+};
+export const deleteConversation = (id) => {
+    return del(`${BASE}/conversations/${id}`);
+};
+export const history = (sessionId) => {
+    return get(`${BASE}/history`, { query: { sessionId } });
+};
+export const feedback = (messageId, helpful) => {
+    return post(`${BASE}/messages/${messageId}/feedback`, { helpful });
+};
+export const escalate = (sessionId, topic) => {
+    return post(`${BASE}/escalate`, { sessionId, topic });
+};
+export const usage = () => {
+    return get(`${BASE}/usage`);
+};
+export const confirmAction = (sessionId, a) => {
+    return post(`${BASE}/${sessionId}/confirm-action`, { kind: a.kind, payloadJson: a.payloadJson, nonce: a.nonce });
+};
 const TABLE = new Set([".xlsx", ".csv"]);
 const IMAGE = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
 const TEXT = new Set([".txt", ".md", ".json", ".log", ".yml", ".yaml", ".tsv", ".xml", ".html", ".sql"]);
@@ -187,6 +207,8 @@ const FINANCE = /payment|invoice|einvoice|finance|refund|payout|wallet|billing|t
 const LARGE = /delete|remove|merge|bulk|batch|mass|permission|role|group|xoa|gop|hang.?loat|campaign|broadcast/i;
 /** Large = deletes, merges, permission changes, > 20 records or recipients. Finance never runs from the terminal. */
 export function riskOf(a) {
+    if (a.risk)
+        return a.risk;
     if (FINANCE.test(a.kind))
         return "finance";
     if (LARGE.test(a.kind))

package/dist/ai/local.js

@@ -0,0 +1,286 @@
+// --model: the agent loop runs on this machine with the user's own model; tools come from the workspace's
+// MCP server. Writes follow MCP rules (a proposal with a confirmation link), so the loop never writes by itself.
+// Emits the same StreamChunk events as the platform assistant, so the REPL and -p render both the same way.
+import Anthropic from "@anthropic-ai/sdk";
+import { fetch } from "undici";
+import { CliError, Exit } from "../core/errors.js";
+import { tr, currentLang } from "../core/i18n.js";
+import { brand } from "../core/brand.js";
+import { getProfile } from "../core/config.js";
+import { context } from "../core/context.js";
+import { networkError, serverMessage, userAgent } from "../core/http.js";
+import { McpClient, resultValue } from "../mcp/client.js";
+const MAX_STEPS = 25;
+/** Tool output beyond this is cut with a note; one report can otherwise fill the model's context. */
+const MAX_RESULT_CHARS = 60_000;
+/** Models that accept the server-side refusal fallback ("default" routing). */
+const FALLBACK_MODELS = /^claude-(fable-5-1|opus-5-5|opus-5|sonnet-5-5)$/;
+/** Provider tool names allow [A-Za-z0-9_-] only; MCP names may carry dots. */
+const wireName = (n) => n.replace(/[^A-Za-z0-9_-]/g, "__").slice(0, 64);
+function systemPrompt(readOnly) {
+    const b = brand();
+    const p = getProfile(context().profile);
+    const lang = currentLang() === "en" ? "English" : "Vietnamese";
+    return [
+        `You are a terminal assistant for ${b.name}, working on the user's live workspace data through the tools provided.`,
+        `Workspace: ${p?.workspaceName ?? p?.workspaceCode ?? "-"} (${context().env}). Today: ${new Date().toISOString().slice(0, 10)}.`,
+        "Answer from tool results only; if no tool can answer, say so instead of guessing numbers.",
+        readOnly
+            ? "This session is read-only: do not try to change data."
+            : "Tools that change data only create a proposal and return a confirmation link. Nothing is saved until the user opens the link and confirms. Show the link and say clearly that the change is not made yet.",
+        `Reply in ${lang} unless the user writes in another language. Output is shown in a terminal: short paragraphs, plain Markdown lists and tables, no HTML.`,
+    ].join("\n");
+}
+function resultText(r) {
+    const v = resultValue(r);
+    const s = typeof v === "string" ? v : JSON.stringify(v);
+    return s.length > MAX_RESULT_CHARS ? `${s.slice(0, MAX_RESULT_CHARS)}\n[… ${s.length - MAX_RESULT_CHARS} more characters cut]` : s;
+}
+export class LocalChat {
+    model;
+    readOnly;
+    mcp;
+    tools;
+    claudeHistory = [];
+    chatHistory = [];
+    anthropic;
+    constructor(model, interactive, readOnly = false) {
+        this.model = model;
+        this.readOnly = readOnly;
+        this.mcp = new McpClient(interactive);
+    }
+    async loadTools() {
+        if (this.tools)
+            return this.tools;
+        const all = await this.mcp.listTools();
+        const usable = this.readOnly ? all.filter((t) => t.annotations?.readOnlyHint) : all;
+        const seen = new Set();
+        this.tools = usable
+            .map((tool) => ({ wire: wireName(tool.name), tool }))
+            .filter((t) => !seen.has(t.wire) && seen.add(t.wire));
+        return this.tools;
+    }
+    async runTool(wire, args, onChunk, outcome) {
+        const t = this.tools?.find((x) => x.wire === wire);
+        if (!t)
+            return { text: `Unknown tool ${wire}`, isError: true };
+        const label = t.tool.annotations?.title ?? t.tool.title ?? t.tool.name;
+        const started = Date.now();
+        const activity = { kind: "tool", label, toolName: t.tool.name, elapsedMs: null };
+        if (!args || typeof args !== "object" || Array.isArray(args))
+            return { text: "Tool input must be a JSON object.", isError: true };
+        try {
+            const r = await this.mcp.callTool(t.tool.name, args);
+            activity.elapsedMs = Date.now() - started;
+            outcome.activities.push(activity);
+            onChunk({ type: "activity", activity });
+            return { text: resultText(r), isError: !!r.isError };
+        }
+        catch (e) {
+            // An expired MCP grant ends the turn; other failures go back to the model so it can adjust.
+            if (e instanceof CliError && e.exitCode === Exit.auth)
+                throw e;
+            activity.elapsedMs = Date.now() - started;
+            outcome.activities.push(activity);
+            onChunk({ type: "activity", activity });
+            return { text: e.message, isError: true };
+        }
+    }
+    async ask(input) {
+        const tools = await this.loadTools();
+        const outcome = { text: "", notices: [], activities: [], ended: "done" };
+        if (this.model.api === "anthropic")
+            await this.askClaude(input, tools, outcome);
+        else
+            await this.askChat(input, tools, outcome);
+        outcome.done = { type: outcome.ended, text: outcome.text };
+        input.onChunk(outcome.done);
+        return outcome;
+    }
+    // ── Anthropic Messages ───────────────────────────────────────────────────────────────────────────
+    async askClaude(input, tools, outcome) {
+        this.anthropic ??= new Anthropic({ apiKey: this.model.apiKey, baseURL: this.model.baseUrl, defaultHeaders: { "User-Agent": userAgent() } });
+        const defs = tools.map((t) => ({
+            name: t.wire,
+            description: (t.tool.description ?? t.tool.title ?? t.tool.name).slice(0, 4000),
+            input_schema: (t.tool.inputSchema ?? { type: "object", properties: {} }),
+        }));
+        const fallback = FALLBACK_MODELS.test(this.model.model);
+        this.claudeHistory.push({ role: "user", content: input.text });
+        for (let step = 0; step < MAX_STEPS; step++) {
+            let msg;
+            try {
+                const stream = this.anthropic.beta.messages.stream({
+                    model: this.model.model,
+                    max_tokens: 32_000,
+                    system: [{ type: "text", text: systemPrompt(this.readOnly), cache_control: { type: "ephemeral" } }],
+                    tools: defs,
+                    messages: this.claudeHistory,
+                    ...(fallback ? { betas: ["server-side-fallback-2026-07-01"], fallbacks: "default" } : {}),
+                }, { signal: input.signal });
+                stream.on("text", (d) => {
+                    outcome.text += d;
+                    input.onChunk({ type: "token", text: d });
+                });
+                msg = await stream.finalMessage();
+            }
+            catch (e) {
+                throw anthropicError(e, input.signal);
+            }
+            // Append the whole content (thinking and fallback blocks included) so the next turn replays it unchanged.
+            this.claudeHistory.push({ role: "assistant", content: msg.content });
+            if (msg.stop_reason === "refusal") {
+                outcome.notices.push({ code: "model_refusal", message: tr("Model từ chối trả lời câu này.", "The model declined to answer this.") });
+                outcome.ended = "error";
+                return;
+            }
+            const uses = msg.content.filter((b) => b.type === "tool_use");
+            if (msg.stop_reason === "max_tokens") {
+                outcome.notices.push({ code: "model_max_tokens", message: tr("Câu trả lời bị cắt vì quá dài.", "The answer was cut off for length.") });
+                // A tool call cut mid-input must not run; close it so the history stays valid.
+                if (uses.length)
+                    this.claudeHistory.push({ role: "user", content: uses.map((u) => ({ type: "tool_result", tool_use_id: u.id, content: "Not run: the call was cut off.", is_error: true })) });
+                return;
+            }
+            if (msg.stop_reason === "pause_turn")
+                continue;
+            if (msg.stop_reason !== "tool_use" || !uses.length)
+                return;
+            if (outcome.text && !outcome.text.endsWith("\n")) {
+                outcome.text += "\n";
+                input.onChunk({ type: "token", text: "\n" });
+            }
+            const results = await Promise.all(uses.map((u) => this.runTool(u.name, u.input, input.onChunk, outcome)));
+            this.claudeHistory.push({
+                role: "user",
+                content: uses.map((u, i) => ({ type: "tool_result", tool_use_id: u.id, content: results[i].text, ...(results[i].isError ? { is_error: true } : {}) })),
+            });
+        }
+        outcome.notices.push({ code: "model_steps", message: tr(`Dừng sau ${MAX_STEPS} bước gọi công cụ.`, `Stopped after ${MAX_STEPS} tool steps.`) });
+    }
+    // ── chat-completions (GPT, Gemini, Grok, Ollama) ─────────────────────────────────────────────────
+    async askChat(input, tools, outcome) {
+        const defs = tools.map((t) => ({
+            type: "function",
+            function: { name: t.wire, description: (t.tool.description ?? t.tool.title ?? t.tool.name).slice(0, 1000), parameters: t.tool.inputSchema ?? { type: "object", properties: {} } },
+        }));
+        if (!this.chatHistory.length)
+            this.chatHistory.push({ role: "system", content: systemPrompt(this.readOnly) });
+        this.chatHistory.push({ role: "user", content: input.text });
+        for (let step = 0; step < MAX_STEPS; step++) {
+            const turn = await this.chatTurn(defs, input, outcome);
+            this.chatHistory.push({ role: "assistant", content: turn.content || null, ...(turn.calls.length ? { tool_calls: turn.calls } : {}) });
+            if (turn.finish === "length") {
+                outcome.notices.push({ code: "model_max_tokens", message: tr("Câu trả lời bị cắt vì quá dài.", "The answer was cut off for length.") });
+                for (const call of turn.calls)
+                    this.chatHistory.push({ role: "tool", tool_call_id: call.id, content: "Not run: the call was cut off." });
+                return;
+            }
+            if (!turn.calls.length)
+                return;
+            if (outcome.text && !outcome.text.endsWith("\n")) {
+                outcome.text += "\n";
+                input.onChunk({ type: "token", text: "\n" });
+            }
+            const results = await Promise.all(turn.calls.map((call) => {
+                let args;
+                try {
+                    args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+                }
+                catch {
+                    return Promise.resolve({ text: "Invalid JSON arguments; send a valid JSON object.", isError: true });
+                }
+                return this.runTool(call.function.name, args, input.onChunk, outcome);
+            }));
+            turn.calls.forEach((call, i) => this.chatHistory.push({ role: "tool", tool_call_id: call.id, content: results[i].isError ? `ERROR: ${results[i].text}` : results[i].text }));
+        }
+        outcome.notices.push({ code: "model_steps", message: tr(`Dừng sau ${MAX_STEPS} bước gọi công cụ.`, `Stopped after ${MAX_STEPS} tool steps.`) });
+    }
+    async chatTurn(defs, input, outcome) {
+        const url = `${this.model.baseUrl}/chat/completions`;
+        let res;
+        try {
+            res = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Accept: "text/event-stream", "User-Agent": userAgent(), ...(this.model.apiKey ? { Authorization: `Bearer ${this.model.apiKey}` } : {}) },
+                body: JSON.stringify({ model: this.model.model, messages: this.chatHistory, ...(defs.length ? { tools: defs } : {}), stream: true }),
+                signal: input.signal,
+            });
+        }
+        catch (e) {
+            throw networkError(e, url);
+        }
+        if (!res.ok) {
+            const body = await res.json().catch(() => undefined);
+            throw providerError(this.model, res.status, serverMessage(body?.error ?? body).message);
+        }
+        let content = "";
+        let finish;
+        const calls = [];
+        const decoder = new TextDecoder();
+        let buf = "";
+        for await (const part of res.body ?? []) {
+            buf += decoder.decode(part, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line.startsWith("data:"))
+                    continue;
+                const data = line.slice(5).trim();
+                if (data === "[DONE]")
+                    continue;
+                let ev;
+                try {
+                    ev = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                const ch = ev.choices?.[0];
+                if (!ch)
+                    continue;
+                if (ch.finish_reason)
+                    finish = ch.finish_reason;
+                const d = ch.delta;
+                if (d?.content) {
+                    content += d.content;
+                    outcome.text += d.content;
+                    input.onChunk({ type: "token", text: d.content });
+                }
+                for (const tc of d?.tool_calls ?? []) {
+                    const i = tc.index ?? calls.length;
+                    calls[i] ??= { id: tc.id ?? `call_${i}`, type: "function", function: { name: "", arguments: "" } };
+                    if (tc.id)
+                        calls[i].id = tc.id;
+                    if (tc.function?.name)
+                        calls[i].function.name += tc.function.name;
+                    if (tc.function?.arguments)
+                        calls[i].function.arguments += tc.function.arguments;
+                }
+            }
+        }
+        return { content, calls: calls.filter(Boolean), finish };
+    }
+}
+function providerError(m, status, message) {
+    const who = m.label;
+    if (status === 401 || status === 403)
+        return new CliError(tr(`${who}: khoá model bị từ chối.`, `${who}: the model key was rejected.`) + (message ? ` (${message})` : ""), Exit.auth, `${brand().bin} model add ${m.provider} --key-from-stdin`);
+    if (status === 404)
+        return new CliError(tr(`${who}: không có model này.`, `${who}: no such model.`) + (message ? ` (${message})` : ""), Exit.notFound);
+    if (status === 429)
+        return new CliError(tr(`${who}: nhà model đang giới hạn tốc độ hoặc hết hạn mức.`, `${who}: the provider is rate limiting or out of quota.`) + (message ? ` (${message})` : ""), Exit.quota);
+    return new CliError(`${who}: HTTP ${status}${message ? ` ${message}` : ""}`, Exit.general);
+}
+function anthropicError(e, signal) {
+    if (signal?.aborted || e instanceof Anthropic.APIUserAbortError)
+        return new CliError(tr("Đã dừng.", "Stopped."), Exit.interrupted);
+    if (e instanceof Anthropic.APIConnectionError)
+        return new CliError(tr("Không kết nối được tới nhà model.", "Could not reach the model provider."), Exit.network);
+    if (e instanceof Anthropic.APIError) {
+        const m = { provider: "claude", label: "claude" };
+        return providerError(m, e.status ?? 0, e.message);
+    }
+    return e;
+}

package/dist/ai/models.js

@@ -0,0 +1,87 @@
+// The user's own model (--model): which providers exist, where their keys live, how a spec like
+// "claude", "gpt/<name>" or "ollama/qwen3:32b" resolves. Keys stay in the keychain and never go to the platform.
+import { CliError, Exit } from "../core/errors.js";
+import { tr } from "../core/i18n.js";
+import { brand } from "../core/brand.js";
+import { loadConfig, saveConfig } from "../core/config.js";
+import { readSecret, writeSecret, deleteSecret } from "../auth/credentials.js";
+// A→Z, no provider is favoured.
+export const PROVIDERS = {
+    claude: { label: "Claude (Anthropic)", api: "anthropic", baseUrl: "https://api.anthropic.com", keyEnv: "ANTHROPIC_API_KEY", defaultModel: "claude-opus-5-5", needsKey: true },
+    gemini: { label: "Gemini (Google)", api: "chat", baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai", keyEnv: "GEMINI_API_KEY", needsKey: true },
+    gpt: { label: "GPT (OpenAI)", api: "chat", baseUrl: "https://api.openai.com/v1", keyEnv: "OPENAI_API_KEY", needsKey: true },
+    grok: { label: "Grok (xAI)", api: "chat", baseUrl: "https://api.x.ai/v1", keyEnv: "XAI_API_KEY", needsKey: true },
+    ollama: { label: "Ollama (máy bạn / your machine)", api: "chat", baseUrl: "http://localhost:11434", needsKey: false },
+};
+const stored = () => loadConfig();
+function save(patch) {
+    const c = loadConfig();
+    patch(c);
+    saveConfig(c);
+}
+export const isProvider = (p) => p in PROVIDERS;
+export function listModels() {
+    const s = stored();
+    return Object.entries(s.models ?? {}).map(([name, entry]) => ({
+        name,
+        entry,
+        hasKey: !PROVIDERS[entry.provider].needsKey || !!keyFor(entry.provider),
+        isDefault: s.defaultModel === name,
+    }));
+}
+export function addModel(provider, opts) {
+    if (PROVIDERS[provider].needsKey && opts.key)
+        writeSecret(`model:${provider}`, opts.key.trim());
+    save((s) => {
+        s.models = { ...s.models, [provider]: { provider, ...(opts.model ? { model: opts.model } : {}), ...(opts.url ? { url: opts.url.replace(/\/+$/, "") } : {}) } };
+    });
+}
+export function removeModel(name) {
+    const s = stored();
+    const entry = s.models?.[name];
+    if (!entry)
+        return false;
+    deleteSecret(`model:${entry.provider}`);
+    save((x) => {
+        delete x.models?.[name];
+        if (x.defaultModel === name)
+            delete x.defaultModel;
+    });
+    return true;
+}
+export function setDefaultModel(name) {
+    save((s) => {
+        if (name)
+            s.defaultModel = name;
+        else
+            delete s.defaultModel;
+    });
+}
+export const defaultModel = () => stored().defaultModel;
+function keyFor(p) {
+    const env = PROVIDERS[p].keyEnv;
+    return (env && process.env[env]) || readSecret(`model:${p}`);
+}
+/** The CLI's own command name (or "default") means the platform assistant: returns undefined. */
+export function resolveModel(spec) {
+    const s = spec.trim();
+    if (!s || s === brand().bin || s === "default")
+        return undefined;
+    const slash = s.indexOf("/");
+    const head = slash < 0 ? s : s.slice(0, slash);
+    const name = slash < 0 ? undefined : s.slice(slash + 1);
+    if (!isProvider(head))
+        throw new CliError(tr(`Không biết nhà model "${head}".`, `Unknown model provider "${head}".`), Exit.usage, tr(`Có: ${Object.keys(PROVIDERS).join(", ")} (vd --model ollama/qwen3:32b)`, `Available: ${Object.keys(PROVIDERS).join(", ")} (e.g. --model ollama/qwen3:32b)`));
+    const info = PROVIDERS[head];
+    const entry = stored().models?.[head];
+    const model = name || entry?.model || info.defaultModel;
+    if (!model)
+        throw new CliError(tr(`Cần tên model cho ${head}.`, `Name the ${head} model.`), Exit.usage, `${brand().bin} --model ${head}/<model>  ·  ${brand().bin} model add ${head} --name <model>`);
+    const apiKey = keyFor(head);
+    if (info.needsKey && !apiKey)
+        throw new CliError(tr(`Chưa có khoá ${info.label}.`, `No ${info.label} key yet.`), Exit.auth, `${brand().bin} model add ${head} --key-from-stdin${info.keyEnv ? tr(` (hoặc đặt ${info.keyEnv})`, ` (or set ${info.keyEnv})`) : ""}`);
+    let baseUrl = entry?.url ?? info.baseUrl;
+    if (head === "ollama")
+        baseUrl = `${baseUrl.replace(/\/v1$/, "")}/v1`;
+    return { provider: head, api: info.api, model, baseUrl, apiKey, label: `${head}/${model}` };
+}

package/dist/auth/ci.js

@@ -53,7 +53,7 @@ export async function loginCi(opts) {
     const json = (await res.json().catch(() => ({})));
     if (!res.ok) {
         if (json.error === "invalid_grant" || json.error === "unauthorized_client")
-            throw new CliError(tr(`Kho/nhánh này chưa được phép đăng nhập (${provider}). Quản trị khai báo ở ${ep.app} › Thiết lập › Ứng dụng & API › CI.`, `This repository/branch is not allowed to log in (${provider}). An admin can allow it at ${ep.app} › Settings › Apps & API › CI.`), Exit.auth, String(json.error_description ?? ""));
+            throw new CliError(tr(`Kho/nhánh này chưa được phép đăng nhập (${provider}). Quản trị khai báo ở ${ep.app} › ${brand().ciSettings.vi}.`, `This repository/branch is not allowed to log in (${provider}). An admin can allow it at ${ep.app} › ${brand().ciSettings.en}.`), Exit.auth, String(json.error_description ?? ""));
         throw errorFor(res.status, json, res);
     }
     const session = sessionFrom({ ...json, refresh_token: "ci" }, "ci");

package/dist/auth/mcp-oauth.js

@@ -1,7 +1,6 @@
 // Delegated OAuth for the hosted MCP server. Tool catalog and tool calls only accept tokens issued for the
-// MCP resource (RFC 8707), so the CLI registers itself like any MCP client: dynamic client registration
-// (public, PKCE, loopback), one consent in the browser, then refresh tokens.
-import { hostname } from "node:os";
+// MCP resource (RFC 8707): public client identified by its metadata document URL, PKCE + loopback, one consent
+// in the browser, then refresh tokens.
 import { fetch } from "undici";
 import { brand } from "../core/brand.js";
 import { context } from "../core/context.js";
@@ -46,6 +45,13 @@ async function discover() {
         throw errorFor(a.res.status, a.body, a.res);
     return { resource: r.body, as: a.body, asUrl };
 }
+/**
+ * The CLI's client_id is the URL of its metadata document on the developer portal (Client ID Metadata Document).
+ * The portal's domain is trusted by the authorization server, so the CLI counts as a verified AI app and works in
+ * workspaces that allow verified apps only (the default) — a self-registered (DCR) client never would.
+ * Each environment uses its own portal (both are trusted by their authorization server).
+ */
+export const cliClientId = () => `${context().endpoints.docs}/cli/oauth-client.json`;
 /** Scopes to ask for: everything the server offers, limited to the brand's modules. */
 function wantedScopes(offered) {
     const mods = brand().modules;
@@ -53,28 +59,9 @@ function wantedScopes(offered) {
 }
 export async function authorizeMcp(opts = {}) {
     const { resource, as, asUrl } = await discover();
-    if (!as.registration_endpoint)
-        throw new CliError(tr("Máy chủ không cho đăng ký client.", "The server does not allow client registration."), Exit.general);
     const p = pkce();
     const waiter = await waitForCode(p.state);
-    const prev = readGrant();
-    let clientId = prev?.authServer === asUrl ? prev.clientId : undefined;
-    if (!clientId) {
-        const reg = await json(as.registration_endpoint, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                client_name: `${brand().name} CLI (${hostname()})`,
-                client_uri: context().endpoints.docs + "/docs/cli",
-                redirect_uris: ["http://127.0.0.1/callback"],
-                grant_types: ["authorization_code", "refresh_token"],
-                token_endpoint_auth_method: "none",
-            }),
-        });
-        if (!reg.res.ok)
-            throw errorFor(reg.res.status, reg.body, reg.res);
-        clientId = reg.body.client_id;
-    }
+    const clientId = cliClientId();
     const scope = wantedScopes(resource.scopes_supported ?? []);
     const url = new URL(as.authorization_endpoint);
     url.search = new URLSearchParams({

package/dist/auth/session.js

@@ -79,6 +79,12 @@ export function sessionFrom(body, via, prev) {
  * Refreshes the stored session. `staleAccess` is the token the caller saw: if another process already
  * replaced it while we waited for the lock, its result is reused instead of refreshing again.
  */
+/** Body for `/iam/auth/refresh-token`. An IAM that speaks snake_case ignores a camelCase key and answers 401 "required". */
+export function refreshBody(url, refreshToken) {
+    const body = { refreshToken };
+    void url;
+    return JSON.stringify(body);
+}
 export async function refreshSession(staleAccess) {
     const profile = context().profile;
     return withFileLock(lockFile(profile), async () => {
@@ -99,7 +105,7 @@ export async function refreshSession(staleAccess) {
             res = await fetch(url, {
                 method: "POST",
                 headers: { "Content-Type": "application/json", "X-Client-Type": "cli", "User-Agent": `${brand().bin}-cli` },
-                body: JSON.stringify({ refreshToken: s.refreshToken }),
+                body: refreshBody(url, s.refreshToken),
             });
         }
         catch (e) {