@nextxai/cli 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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.
@@ -15,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

@@ -7,21 +7,37 @@ import { get, post, put, patch, del, requestRaw, errorFor, networkError } from "
 import { CliError, Exit } from "../core/errors.js";
 import { tr } from "../core/i18n.js";
 import { brand } from "../core/brand.js";
-import * as nf from "./nextfarm.js";
-/** NextFarm talks to its own assistant API (see nextfarm.ts); the other brands share this file's contract. */
-const farm = () => brand().platform === "nextfarm";
 const BASE = "/operator/widget/support";
-export const openConversation = (forceNew) => farm() ? nf.openConversation(forceNew) : post(`${BASE}/init`, { forceNew });
-export const listConversations = (limit = 30) => farm() ? nf.listConversations(limit) : get(`${BASE}/conversations`, { query: { limit } });
-export const renameConversation = (id, title) => farm() ? nf.renameConversation(id, title) : patch(`${BASE}/conversations/${id}/title`, { title });
-export const pinConversation = (id, pinned) => farm() ? nf.pinConversation(id, pinned) : put(`${BASE}/conversations/${id}/pin`, { pinned });
-export const deleteConversation = (id) => farm() ? nf.deleteConversation(id) : del(`${BASE}/conversations/${id}`);
-export const history = (sessionId) => farm() ? nf.history(sessionId) : get(`${BASE}/history`, { query: { sessionId } });
-export const feedback = (messageId, helpful) => farm() ? nf.feedback(messageId, helpful) : post(`${BASE}/messages/${messageId}/feedback`, { helpful });
-export const escalate = (sessionId, topic) => farm() ? nf.escalate(sessionId, topic) : post(`${BASE}/escalate`, { sessionId, topic });
-export const usage = () => farm() ? nf.usage() : get(`${BASE}/usage`);
-export const confirmAction = (sessionId, a) => farm() ? nf.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"]);
@@ -29,8 +45,6 @@ const MAX_BYTES = 10 * 1024 * 1024;
 const MAX_TEXT = 20_000;
 export function attachmentKind(path) {
     const ext = extname(path).toLowerCase();
-    if (farm() && nf.isDocument(path))
-        return "table";
     if (TABLE.has(ext))
         return "table";
     if (ext in IMAGE)
@@ -67,8 +81,6 @@ export async function attach(path, sessionId) {
         const cut = raw.length > MAX_TEXT;
         return { path, name, kind, text: cut ? raw.slice(0, MAX_TEXT) : raw, summary: tr(`${raw.length.toLocaleString("vi-VN")} ký tự${cut ? ", đã cắt" : ""}`, `${raw.length} chars${cut ? ", truncated" : ""}`) };
     }
-    if (farm())
-        return nf.attachBinary(path, kind);
     if (size > MAX_BYTES)
         throw new CliError(tr("Tệp quá lớn (tối đa 10 MB).", "File too large (max 10 MB)."), Exit.usage);
     const body = readFileSync(path);
@@ -98,8 +110,6 @@ export function composeText(question, attachments, projectNotes) {
  * so the server replays the stored answer instead of answering (and charging) twice.
  */
 export async function ask(input) {
-    if (farm())
-        return nf.ask(input);
     const key = randomUUID();
     const body = {
         sessionId: input.sessionId,

package/dist/auth/session.js

@@ -2,7 +2,6 @@
 // Order: <PREFIX>_API_KEY → <PREFIX>_TOKEN → stored session of the profile. `status` prints which one is used.
 import { fetch } from "undici";
 import { brand, envVar } from "../core/brand.js";
-import { snakeKeys, snakeOnWire } from "../core/case.js";
 import { context } from "../core/context.js";
 import { CliError, Exit } from "../core/errors.js";
 import { t } from "../core/i18n.js";
@@ -80,10 +79,11 @@ 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`. NextFarm IAM is snake_case: a camelCase key is ignored and answers 401 "required". */
+/** 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 };
-    return JSON.stringify(snakeOnWire(url) ? snakeKeys(body) : body);
+    void url;
+    return JSON.stringify(body);
 }
 export async function refreshSession(staleAccess) {
     const profile = context().profile;

package/dist/commands/ai.js

@@ -14,7 +14,6 @@ import { ask, attach, attachmentKind, composeText, confirmAction, listConversati
 import { LocalChat } from "../ai/local.js";
 import { mcpToken } from "../auth/mcp-oauth.js";
 import { defaultModel, resolveModel } from "../ai/models.js";
-import { registerAiNextFarm } from "./ai-nextfarm.js";
 // ── NEXTX.md ───────────────────────────────────────────────────────────────────────────────────────
 const NOTES_MAX = 4096;
 export function notesFileName() {
@@ -88,14 +87,29 @@ export function proposalCard(a) {
  * Rules (docs §2.6): read mode never writes; finance never from the terminal; no TTY ⇒ never;
  * large writes need the typed number; auto mode skips the y/N for normal writes only.
  */
+/** Thẻ đăng nhập CI (login --ci): không có người bấm, máy chủ quyết theo chính sách duyệt trước (ci policy). */
+async function isCiSession() {
+    const { currentAuth } = await import("../auth/session.js");
+    const a = await currentAuth().catch(() => undefined);
+    return a?.kind === "session" && a.session.via === "ci";
+}
+/** Lệnh để người xác nhận đề xuất sau: nền tảng mặc định mở lại hội thoại, nền tảng khác có thể theo id đề xuất. */
+function confirmHint(nonce, conversationId) {
+    return `${brand().bin} -r ${conversationId}`;
+}
+/** 403 của cổng ghi CI ⇒ việc chưa ghi, đề xuất còn chờ người duyệt — báo rõ, không coi là lỗi chương trình. */
+function ciDenied(e) {
+    const err = e;
+    return err instanceof CliError && err.exitCode === Exit.forbidden ? err.message : undefined;
+}
 export async function handleProposal(sessionId, a, mode = context().mode) {
     if (!a.writes) {
         const r = await confirmAction(sessionId, a);
         return { written: false, message: r.message };
     }
     const risk = riskOf(a);
-    // NextFarm proposals are confirmed by id; the default platform's by reopening the conversation.
-    const resume = brand().platform === "nextfarm" ? `${brand().bin} ai apply ${a.nonce}` : `${brand().bin} -r ${sessionId}`;
+    // Đề xuất của nền tảng mặc định xác nhận bằng cách mở lại hội thoại.
+    let resume = `${brand().bin} -r ${sessionId}`;
     if (mode === "read") {
         info(c.dim(tr("  Chế độ chỉ đọc: không ghi. Đổi chế độ: --mode propose", "  Read-only mode: nothing written. Switch with --mode propose")));
         return { written: false };
@@ -107,6 +121,25 @@ export async function handleProposal(sessionId, a, mode = context().mode) {
         return { written: false };
     }
     if (!hasTty()) {
+        // CI + --mode auto: gửi Xác nhận, máy chủ chỉ ghi trong chính sách duyệt trước của kho này (ci policy).
+        if (brand().platform === "nextx" && mode === "auto" && (await isCiSession())) {
+            try {
+                const r = await confirmAction(sessionId, a);
+                if (r.success)
+                    ok(r.message || tr("Đã ghi (CI, trong phạm vi duyệt trước).", "Written (CI, within the pre-approved scope)."));
+                else
+                    warn(r.message);
+                return { written: r.success, message: r.message };
+            }
+            catch (e) {
+                const why = ciDenied(e);
+                if (!why)
+                    throw e;
+                info(`  ${c.yellow("⚠")} ${why}`);
+                info(c.dim(tr(`  Cho CI tự ghi: ${brand().bin} ci policy request`, `  Let CI write: ${brand().bin} ci policy request`)));
+                return { written: false, message: why };
+            }
+        }
         info(tr(`  Chưa ghi. Xác nhận trong 15 phút: ${c.bold(resume)}`, `  Not written. Confirm within 15 minutes: ${c.bold(resume)}`));
         return { written: false };
     }
@@ -248,7 +281,21 @@ async function printAsk(o, question, piped) {
     const conversationId = outcome.sessionId || sessionId;
     updateProfile(context().profile, { lastConversation: conversationId });
     const proposal = outcome.proposedAction;
+    // Written in this run (CI pre-approval, or confirmed at the prompt) ⇒ nothing is left to confirm, exit 0.
+    let written = false;
     if (fmt === "json") {
+        const risk = proposal ? riskOf(proposal) : undefined;
+        const allowedRisk = context().mode !== "read" && risk !== "finance" && risk !== "device";
+        let applied;
+        // Nền tảng mặc định: phiên CI + --mode auto ⇒ gửi Xác nhận, máy chủ chỉ ghi trong chính sách duyệt trước (403 ⇒ chưa ghi, kèm lý do).
+        if (!applied && proposal?.writes && brand().platform === "nextx" && allowedRisk && context().mode === "auto" && !hasTty() && (await isCiSession()))
+            applied = await confirmAction(conversationId, proposal).then((r) => ({ written: r.success, message: r.message }), (e) => {
+                const why = ciDenied(e);
+                if (!why)
+                    throw e;
+                return { written: false, message: why };
+            });
+        written = applied?.written ?? false;
         json({
             conversationId,
             runId: outcome.runId ?? null,
@@ -259,7 +306,8 @@ async function printAsk(o, question, piped) {
             notices: outcome.notices,
             agent: outcome.agent ?? null,
             proposals: proposal ? [{ kind: proposal.kind, label: proposal.label, prompt: proposal.confirmPrompt, writes: proposal.writes, expiresAt: proposal.expiresAt ?? null, risk: riskOf(proposal),
-                    confirm: brand().platform === "nextfarm" ? `${brand().bin} ai apply ${proposal.nonce}` : `${brand().bin} -r ${conversationId}` }] : [],
+                    confirm: confirmHint(proposal.nonce, conversationId),
+                    ...(applied ? { applied: { written: applied.written, message: applied.message } } : {}) }] : [],
             workspace: getProfile(context().profile)?.workspaceCode ?? null,
             env: context().env,
             ended: outcome.ended,
@@ -277,12 +325,12 @@ async function printAsk(o, question, piped) {
         if (proposal) {
             for (const l of proposalCard(proposal))
                 stderr.write(`${l}\n`);
-            await handleProposal(conversationId, proposal);
+            written = (await handleProposal(conversationId, proposal)).written;
         }
     }
     if (outcome.notices.some((n) => n.code === "ai_not_purchased"))
         process.exitCode = Exit.forbidden;
-    else if (proposal?.writes)
+    else if (proposal?.writes && !written)
         process.exitCode = Exit.notConfirmed;
     else if (outcome.ended === "error")
         process.exitCode = Exit.general;
@@ -355,8 +403,6 @@ export function registerAi(program) {
         await deleteConversation(id);
         ok(tr("Đã xoá.", "Deleted."));
     });
-    if (brand().platform === "nextfarm")
-        return registerAiNextFarm(ai, program);
     ai.command("why [runId]")
         .description(tr("vì sao AI trả lời vậy: các bước, công cụ đã gọi", "why the AI answered that way: steps and tools"))
         .action(async (runId) => {
@@ -406,13 +452,16 @@ export function registerAi(program) {
         const head = await findChangeset(id);
         if (context().mode === "read")
             throw new CliError(tr("Chế độ chỉ đọc.", "Read-only mode."), Exit.forbidden);
-        if (!hasTty())
-            throw new CliError(tr("Áp dụng bản nháp cần terminal tương tác (hoặc chính sách duyệt trước).", "Applying needs an interactive terminal (or a pre-approval policy)."), Exit.notConfirmed);
+        const ci = !hasTty() && (await isCiSession());
+        if (!hasTty() && !ci)
+            throw new CliError(tr("Áp dụng bản nháp cần terminal tương tác (hoặc đăng nhập CI có phạm vi duyệt trước).", "Applying needs an interactive terminal (or a CI login with a pre-approved scope)."), Exit.notConfirmed);
         const env = context().env === "prod" ? c.red("PROD") : c.yellow("SANDBOX");
         info(`${c.bold(head.title)} · ${env}`);
-        const yes = head.risk >= 3 ? await confirmTyped("", tr("dong-y", "confirm")) : await confirm(tr("Áp dụng?", "Apply?"));
-        if (!yes)
-            return void info(tr("Không ghi gì.", "Nothing written."));
+        if (!ci) {
+            const yes = head.risk >= 3 ? await confirmTyped("", tr("dong-y", "confirm")) : await confirm(tr("Áp dụng?", "Apply?"));
+            if (!yes)
+                return void info(tr("Không ghi gì.", "Nothing written."));
+        }
         const r = await post(`/ai/changesets/${head.id}/apply`, undefined, { query: { expectedVersion: head.version } });
         emit(r, () => ok(tr(`Đã áp dụng · hoàn tác: ${brand().bin} ai undo ${short(head.id)}`, `Applied · undo: ${brand().bin} ai undo ${short(head.id)}`)));
     });

package/dist/commands/ci-policy.js

@@ -0,0 +1,98 @@
+import { brand } from "../core/brand.js";
+import { CliError, Exit } from "../core/errors.js";
+import { tr } from "../core/i18n.js";
+import { c, emit, info, ok, table } from "../core/output.js";
+import { get, post } from "../core/http.js";
+import { confirm, hasTty } from "../core/prompt.js";
+import { context } from "../core/context.js";
+import { requirePerson } from "../auth/session.js";
+import { parseDuration } from "./keys.js";
+const BASE = "/ai/ci-write-policies";
+// Ví dụ + nơi duyệt theo nền tảng: có nền tảng ghi theo loại dòng nhật ký, nền tảng mặc định theo mã quyền ghi.
+const exampleKinds = () => brand().examples.ciKinds;
+function approvePlace() {
+    return tr("Thiết lập › Ứng dụng & API › CI", "Settings › Apps & API › CI");
+}
+const day = (s) => (s ? s.slice(0, 10) : "—");
+const shortId = (id) => id.slice(-8);
+function stateLabel(s) {
+    switch (s) {
+        case "active": return c.green(tr("đang hiệu lực", "active"));
+        case "pending": return c.yellow(tr("chờ duyệt", "pending"));
+        case "exhausted": return c.dim(tr("hết trần", "ceiling reached"));
+        case "expired": return c.dim(tr("hết hạn", "expired"));
+        default: return c.red(tr("đã thu hồi", "revoked"));
+    }
+}
+async function findPolicy(id) {
+    // Id UUID v7: 8 ký tự ĐẦU trùng nhau giữa các chính sách tạo cùng lúc (tiền tố thời gian) ⇒ bảng hiện 8 ký tự CUỐI, tìm khớp cả hai đầu.
+    const all = (await get(BASE)).items;
+    const hits = all.filter((x) => x.id === id || x.id.startsWith(id) || x.id.endsWith(id));
+    if (hits.length > 1)
+        throw new CliError(tr("Mã ngắn trùng nhiều chính sách — gõ thêm ký tự.", "Short id matches several policies — type more characters."), Exit.usage);
+    const p = hits[0];
+    if (!p)
+        throw new CliError(tr("Không thấy chính sách này.", "Policy not found."), Exit.notFound);
+    return p;
+}
+export function registerCiPolicy(ci) {
+    const policy = ci.command("policy")
+        .description(tr("chính sách duyệt trước: cho CI tự ghi trong trần", "pre-approval policies: let CI write within a ceiling"));
+    policy.hook("preAction", async () => { await requirePerson(); });
+    policy.command("list", { isDefault: true }).action(async () => {
+        const { items } = await get(BASE);
+        emit(items, () => info(items.length
+            ? table(["ID", tr("Kho", "Repository"), tr("Được ghi", "Kinds"), tr("Đã dùng", "Used"), tr("Hết hạn", "Expires"), ""], items.map((p) => [
+                shortId(p.id), p.repository ?? shortId(p.ciTrustId), p.kinds.join(", "), `${p.usedRecords}/${p.maxRecords}`, day(p.expiresAt), stateLabel(p.state),
+            ]))
+            : tr(`Chưa có chính sách — CI chỉ in link để xác nhận. Xin: ${brand().bin} ci policy request --trust <kho> --kinds ${exampleKinds()}`, `No policy — CI only prints a link to confirm. Request one: ${brand().bin} ci policy request --trust <repo> --kinds ${exampleKinds()}`)));
+    });
+    policy.command("kinds").description(tr("loại ghi đưa được vào chính sách", "kinds a policy can cover")).action(async () => {
+        const { items } = await get(`${BASE}/kinds`);
+        emit(items, () => info(items.join("\n")));
+    });
+    policy.command("show <id>").action(async (id) => {
+        const p = await findPolicy(id);
+        emit(p, () => {
+            info(`${c.bold(p.repository ?? p.ciTrustId)}  ${stateLabel(p.state)}`);
+            info(tr(`Được ghi: ${p.kinds.join(", ")}`, `Kinds: ${p.kinds.join(", ")}`));
+            info(tr(`Đã dùng: ${p.usedRecords}/${p.maxRecords} · hết hạn ${day(p.expiresAt)} · ghi lần cuối ${day(p.lastUsedAt)}`, `Used: ${p.usedRecords}/${p.maxRecords} · expires ${day(p.expiresAt)} · last write ${day(p.lastUsedAt)}`));
+            if (p.note)
+                info(c.dim(p.note));
+        });
+    });
+    policy.command("request")
+        .description(tr("xin cho một kho CI tự ghi (người quản lý khoá API duyệt; có quyền thì có hiệu lực ngay)", "ask to let a CI repository write (an API-key manager approves; with that permission it is active at once)"))
+        .requiredOption("--trust <id|owner/repo>", tr("khai báo CI (xem: ci trust list)", "CI trust (see: ci trust list)"))
+        .requiredOption("--kinds <a,b>", tr("loại ghi (xem: ci policy kinds)", "kinds (see: ci policy kinds)"))
+        .option("--max <n>", tr("trần số bản ghi (1–1000)", "record ceiling (1–1000)"), "50")
+        .option("--expires <dur>", tr("thời hạn tối đa 30d", "lifetime, at most 30d"), "14d")
+        .option("--note <text>")
+        .option("--approve", tr("duyệt luôn (cần quyền quản lý khoá API)", "approve now (needs API-key manage permission)"))
+        .action(async (o) => {
+        const want = o.trust.trim().toLowerCase();
+        const trust = (await get("/iam/ci-trusts")).find((t) => !t.revokedAt && (t.id.startsWith(want) || t.repository === want));
+        if (!trust)
+            throw new CliError(tr(`Không thấy kho CI "${o.trust}".`, `No CI trust "${o.trust}".`), Exit.notFound, `${brand().bin} ci trust list`);
+        const max = Number(o.max);
+        if (!Number.isInteger(max) || max < 1 || max > 1000)
+            throw new CliError(tr("--max từ 1 đến 1000.", "--max must be 1–1000."), Exit.usage);
+        const p = await post(BASE, {
+            ciTrustId: trust.id, repository: trust.repository, kinds: o.kinds.split(",").map((k) => k.trim()).filter(Boolean),
+            maxRecords: max, expiresAt: parseDuration(o.expires), note: o.note ?? null, approve: !!o.approve,
+        });
+        emit(p, () => {
+            ok(p.state === "active"
+                ? tr(`CI của ${trust.repository} được tự ghi ${p.kinds.join(", ")} — tối đa ${p.maxRecords} bản ghi tới ${day(p.expiresAt)}.`, `CI of ${trust.repository} may write ${p.kinds.join(", ")} — up to ${p.maxRecords} records until ${day(p.expiresAt)}.`)
+                : tr(`Đã gửi duyệt (${shortId(p.id)}). Người quản lý duyệt tại ${context().endpoints.app} › ${approvePlace()}.`, `Sent for approval (${shortId(p.id)}). A manager approves in ${context().endpoints.app} › ${approvePlace()}.`));
+        });
+    });
+    policy.command("revoke <id>").description(tr("thu hồi (lượt ghi kế tiếp quay về chỉ in link)", "revoke (the next write goes back to a link)"))
+        .action(async (id) => {
+        const p = await findPolicy(id);
+        if (hasTty() && !(await confirm(tr(`Thu hồi chính sách của ${p.repository ?? shortId(p.id)}?`, `Revoke the policy for ${p.repository ?? shortId(p.id)}?`))))
+            return;
+        await post(`${BASE}/${p.id}/revoke`, {});
+        ok(tr("Đã thu hồi.", "Revoked."));
+    });
+}

package/dist/commands/ci.js

@@ -6,6 +6,13 @@ import { get, post } from "../core/http.js";
 import { confirm, hasTty } from "../core/prompt.js";
 import { requirePerson } from "../auth/session.js";
 import { parseDuration } from "./keys.js";
+import { registerCiPolicy } from "./ci-policy.js";
+async function findTrust(id) {
+    const t = (await get("/iam/ci-trusts")).find((x) => x.id.startsWith(id) || x.repository === id);
+    if (!t)
+        throw new CliError(tr("Không thấy khai báo này.", "Not found."), Exit.notFound);
+    return t;
+}
 const when = (s) => (s ? s.slice(0, 16).replace("T", " ") : "—");
 export function workflowSample(repo = "acme/web", ws = "my-workspace") {
     const b = brand();
@@ -20,6 +27,21 @@ jobs:
       - run: npx -y ${b.pkg} login --ci --workspace ${ws}
       - run: npx -y ${b.pkg} -p "${tr(b.example.vi, b.example.en)}" --json > report.json`;
 }
+/** Mẫu CI có GHI: chỉ chạy được sau khi quản trị mở phạm vi (ci trust set --allow … --max-per-run …). */
+export function workflowWriteSample(repo = "acme/web", ws = "my-workspace") {
+    const b = brand();
+    return `# .github/workflows/follow-up.yml  (${repo})
+# ${tr("Ghi chỉ trong chính sách duyệt trước (ci policy request); ngoài phạm vi thì để lại đề xuất chờ người duyệt (mã thoát 7).", "Writes only within an approved policy (ci policy request); anything else stays a proposal for a person (exit code 7).")}
+permissions:
+  id-token: write
+  contents: read
+jobs:
+  follow-up:
+    runs-on: ubuntu-latest
+    steps:
+      - run: npx -y ${b.pkg} login --ci --workspace ${ws}
+      - run: npx -y ${b.pkg} -p "${tr("tạo việc gọi lại cho khách quá hạn chăm sóc 7 ngày", "create call-back tasks for customers not contacted in 7 days")}" --mode auto`;
+}
 export function registerCi(program) {
     const ci = program.command("ci").description(tr("đăng nhập từ CI không cần bí mật (OIDC)", "secretless CI login (OIDC)"));
     const trust = ci.command("trust").description(tr("kho CI được phép đăng nhập workspace này", "CI repositories allowed to log in to this workspace"));
@@ -53,20 +75,22 @@ export function registerCi(program) {
         });
         emit(t, () => {
             ok(tr(`Đã cho ${t.provider}:${t.repository} (${t.refPattern}) đăng nhập`, `Allowed ${t.provider}:${t.repository} (${t.refPattern})`));
+            info(c.dim(tr(`\nCho CI tự ghi trong trần: ${brand().bin} ci policy request --trust ${t.repository} --kinds <mã>`, `\nLet CI write within a ceiling: ${brand().bin} ci policy request --trust ${t.repository} --kinds <code>`)));
             info(c.dim(tr("\nMẫu workflow:", "\nSample workflow:")));
             info(workflowSample(t.repository));
         });
     });
     trust.command("revoke <id>").description(tr("thu hồi (có hiệu lực ngay)", "revoke (immediate)")).action(async (id) => {
-        const t = (await get("/iam/ci-trusts")).find((x) => x.id.startsWith(id) || x.repository === id);
-        if (!t)
-            throw new CliError(tr("Không thấy khai báo này.", "Not found."), Exit.notFound);
+        const t = await findTrust(id);
         if (hasTty() && !(await confirm(tr(`Thu hồi ${t.repository}?`, `Revoke ${t.repository}?`))))
             return;
         await post(`/iam/ci-trusts/${t.id}/revoke`, {});
         ok(tr("Đã thu hồi.", "Revoked."));
     });
+    // Chính sách duyệt trước: cùng hợp đồng /ai/ci-write-policies trên mọi nền tảng.
+    registerCiPolicy(ci);
     ci.command("example").description(tr("in mẫu workflow GitHub Actions", "print a sample GitHub Actions workflow"))
         .option("--repo <owner/repo>").option("--workspace <code>")
-        .action((o) => info(workflowSample(o.repo, o.workspace)));
+        .option("--write", tr("mẫu có tự ghi (cần chính sách: ci policy request)", "sample that writes (needs a policy: ci policy request)"))
+        .action((o) => info(o.write ? workflowWriteSample(o.repo, o.workspace) : workflowSample(o.repo, o.workspace)));
 }

package/dist/commands/keys.js

@@ -20,6 +20,7 @@ async function findKey(id) {
         throw new CliError(tr("Không thấy khoá này.", "Key not found."), Exit.notFound);
     return k;
 }
+const scopeExample = () => brand().examples.scopes;
 export function registerKeys(program) {
     const keys = program.command("keys").description(tr("khoá API của workspace", "workspace API keys"));
     keys.hook("preAction", async () => void (await requirePerson()));
@@ -33,7 +34,7 @@ export function registerKeys(program) {
     keys.command("create")
         .description(tr("tạo khoá mới (in khoá đúng một lần)", "create a key (printed once)"))
         .requiredOption("--name <name>")
-        .requiredOption("--scopes <codes>", tr("mã quyền, phẩy ngăn cách, vd crm.contacts.view,sales.orders.view", "permission codes, comma separated, e.g. crm.contacts.view,sales.orders.view"))
+        .requiredOption("--scopes <codes>", tr(`mã quyền, phẩy ngăn cách, vd ${scopeExample()}`, `permission codes, comma separated, e.g. ${scopeExample()}`))
         .option("--expires <dur>", tr("thời hạn: 30d, 6m, 1y", "lifetime: 30d, 6m, 1y"), "90d")
         .option("--description <text>")
         .action(async (o) => {

package/dist/commands/mcp.js

@@ -5,7 +5,7 @@ import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { fetch } from "undici";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-import { brand, envVar } from "../core/brand.js";
+import { brand } from "../core/brand.js";
 import { context } from "../core/context.js";
 import { CliError, Exit } from "../core/errors.js";
 import { tr } from "../core/i18n.js";
@@ -138,8 +138,8 @@ export function registerMcp(program) {
 }
 /** Line-delimited JSON-RPC on stdio ⇄ Streamable HTTP to the hosted server. Logs go to stderr only. */
 async function serveStdio() {
-    // NextFarm API keys speak MCP through the gateway (same read-only route rules as the key everywhere else).
-    const apiKey = brand().platform === "nextfarm" ? envVar("API_KEY") : undefined;
+    // On some platforms an API key speaks MCP through the gateway (same read-only route rules as the key everywhere else).
+    let apiKey = undefined;
     const url = apiKey ? `${context().endpoints.api}/api/v1/mcp` : context().endpoints.mcp;
     let token = apiKey ?? (await mcpToken({ interactive: false }));
     let sessionId;

package/dist/commands/tools.js

@@ -1,6 +1,5 @@
 import { Option } from "commander";
 import { readFileSync } from "node:fs";
-import { context } from "../core/context.js";
 import { brand, envVar } from "../core/brand.js";
 import { CliError, Exit } from "../core/errors.js";
 import { currentLang, tr } from "../core/i18n.js";
@@ -12,17 +11,12 @@ import { authorizeMcp, readGrant, revokeGrant } from "../auth/mcp-oauth.js";
 import { browserAvailable } from "./auth.js";
 let publicCache;
 export async function publicTools() {
-    publicCache ??= (brand().platform === "nextfarm" ? await nextFarmPublicTools() : await get("/ai/public/tools", { anonymous: true }))
+    publicCache ??= (await loadPublicTools())
         .filter((t) => !brand().modules || brand().modules.includes(t.module));
     return publicCache;
 }
-/** NextFarm: `{ version, tools: [{ name, service, scope, title, title_en, summary, summary_en, parameters, example_args }] }`, read verbatim so schema property names stay as the tool expects them. */
-async function nextFarmPublicTools() {
-    const r = await get("/ai/public/tools", { anonymous: true, verbatim: true });
-    return r.tools.map((t) => ({
-        name: t.name, module: t.service, title: t.title, summary: t.summary, summaryEn: t.summary_en, scope: t.scope,
-        kind: t.scope?.endsWith(":write") ? "write" : "read", parameters: t.parameters, exampleArgs: t.example_args,
-    }));
+async function loadPublicTools() {
+    return get("/ai/public/tools", { anonymous: true });
 }
 /** MCP names may differ from catalog names (module prefix, dots); match loosely. */
 export function sameTool(a, b) {
@@ -161,21 +155,7 @@ export function registerTools(program) {
         .action(async (name, o) => {
         const args = parseArgs(o);
         let value;
-        if (envVar("API_KEY") && brand().platform === "nextfarm") {
-            // NextFarm has no REST door for tools: the API key speaks MCP through the gateway, which keeps its read-only route rules.
-            const client = new McpClient(false, envVar("API_KEY"), `${context().endpoints.api}/api/v1/mcp`);
-            const tool = (await client.listTools()).find((t) => sameTool(t.name, name));
-            if (!tool)
-                throw new CliError(tr("Khoá này không thấy công cụ đó (thiếu phạm vi?).", "This key cannot see that tool (missing scope?)."), Exit.notFound, `${brand().bin} tools list`);
-            const r = await client.callTool(tool.name, args);
-            value = resultValue(r);
-            if (r.isError) {
-                emit({ error: value }, () => info(c.red(typeof value === "string" ? value : JSON.stringify(value, null, 2))));
-                process.exitCode = Exit.general;
-                return;
-            }
-        }
-        else if (envVar("API_KEY")) {
+        if (envVar("API_KEY")) {
             const pub = (await publicTools()).find((p) => sameTool(p.name, name));
             if (!pub)
                 throw new CliError(tr("Không thấy công cụ công khai này.", "Public tool not found."), Exit.notFound);

package/dist/commands/webhooks.js

@@ -9,25 +9,27 @@ import { c, emit, info, json, ok, table, warn } from "../core/output.js";
 import { get, post, del, requestRaw, errorFor } from "../core/http.js";
 import { confirm, hasTty } from "../core/prompt.js";
 const when = (iso) => (iso ? iso.slice(0, 19).replace("T", " ") : "");
-const farm = () => brand().platform === "nextfarm";
-/** Signature headers per platform: `X-Nextfarm-Signature` on NextFarm, `…-Signature-256` otherwise (both sha256=HMAC(ts.body)). */
-const sigHeader = () => (farm() ? "x-nextfarm-signature" : "x-nextx-signature-256");
-const tsHeader = () => (farm() ? "x-nextfarm-timestamp" : "x-nextx-timestamp");
+/** Platforms whose webhook contract differs (event list shape, endpoints with many events, per-endpoint deliveries, test call). */
+let farm = () => false;
+/** Signature headers per platform: `…-Signature-256` by default (sha256=HMAC(ts.body)). */
+function sigHeader() {
+    return "x-nextx-signature-256";
+}
+function tsHeader() {
+    return "x-nextx-timestamp";
+}
+function sigScheme() {
+    return "Signature-256";
+}
 export async function eventTypes() {
-    if (!farm())
-        return get("/webhook/public/event-types", { anonymous: true });
-    const r = await get("/webhook/public/event-types", { anonymous: true, verbatim: true });
-    return r.events.map((e) => ({
-        event: e.event, service: e.group, title: currentLang() === "en" ? e.title_en ?? e.title : e.title, description: e.description,
-        descriptionEn: e.description_en, planRequired: e.scope, payloadSchema: e.payload_schema, example: e.example,
-    }));
+    return get("/webhook/public/event-types", { anonymous: true });
 }
-/** NextFarm endpoints carry `eventTypes` and no single module. */
+/** Some platforms send `eventTypes` per endpoint and no single module. */
 async function listEndpoints() {
     const list = await get("/webhook/endpoints");
     return farm() ? list.map((e) => ({ ...e, events: e.eventTypes ?? [], status: e.isActive ? "active" : "disabled" })) : list;
 }
-/** NextFarm keeps deliveries per endpoint only; the CLI merges them. */
+/** Some platforms keep deliveries per endpoint only; the CLI merges them. */
 async function listDeliveries(o) {
     if (!farm()) {
         const path = o.endpoint ? `/webhook/endpoints/${(await findEndpoint(o.endpoint)).id}/deliveries` : "/webhook/deliveries";
@@ -53,7 +55,7 @@ export function verifySignature(secret, body, headers, toleranceSec = 300) {
         const expected = "sha256=" + createHmac("sha256", secret).update(`${ts}.${body}`).digest("hex");
         const got = [h[sigHeader()], h[`${sigHeader()}-previous`]].filter(Boolean);
         if (got.some((g) => eq(g, expected)))
-            return { ok: true, scheme: farm() ? "X-Nextfarm-Signature" : "Signature-256" };
+            return { ok: true, scheme: sigScheme() };
     }
     if (h["webhook-signature"] && h["webhook-id"] && ts) {
         const key = secret.startsWith("whsec_") ? Buffer.from(secret.slice(6), "base64") : Buffer.from(secret);
@@ -146,7 +148,7 @@ export function registerWebhooks(program) {
         if (!target)
             throw new CliError(tr("Chưa có endpoint nào nhận sự kiện này.", "No endpoint subscribes to this event."), Exit.notFound, tr(`Dùng \`${brand().bin} webhooks listen --events ${event}\` để nghe về máy.`, `Use \`${brand().bin} webhooks listen --events ${event}\` to receive it locally.`));
         if (farm()) {
-            // NextFarm sends a signed `webhook.test` and answers with the receiver's status straight away.
+            // This platform sends a signed `webhook.test` and answers with the receiver's status straight away.
             const t = await post(`/webhook/endpoints/${target.id}/test`, {});
             emit(t, () => (t.ok ? ok : warn)(tr(`Đã gửi webhook.test → ${target.url}`, `Sent webhook.test → ${target.url}`) + ` · ${t.statusCode ? `HTTP ${t.statusCode}` : t.error ?? ""} · ${t.durationMs}ms`));
             if (!t.ok)

package/dist/core/brand.js

@@ -1,6 +1,5 @@
 // One codebase, several branded binaries. The entry file (src/bin/<brand>.ts) picks the brand before
 // anything else is imported; every user-facing name, host and storage location comes from here.
-// <brand:nextx>
 const NEXTX = {
     id: "nextx",
     platform: "nextx",
@@ -11,6 +10,7 @@ const NEXTX = {
     clientId: "nextx-cli",
     envPrefix: "NEXTX",
     mobileApp: "NextX",
+    examples: { scopes: "crm.contacts.view,sales.orders.view", ciKinds: "crm.tasks.create" },
     example: { vi: "doanh thu hôm qua", en: "yesterday's revenue" },
     apiExample: "GET /crm/contacts -f q=Minh",
     ciSettings: { vi: "Thiết lập › Ứng dụng & API › CI", en: "Settings › Apps & API › CI" },
@@ -34,10 +34,9 @@ const NEXTX = {
         },
     },
 };
-// </brand:nextx>
 // Exported trees keep only their own brand (scripts/export.sh strips the other block and its line here).
 const BRANDS = {
-    nextx: NEXTX, // <brand-line:nextx>
+    nextx: NEXTX,
 };
 let current = Object.values(BRANDS)[0];
 export function setBrand(id) {