@nextxai/cli 0.0.0-stage → 0.1.0

package/dist/core/i18n.js

@@ -0,0 +1,90 @@
+// User-facing strings. Vietnamese first; English for --lang en / LANG=en_*.
+import { brand, envVar } from "./brand.js";
+import { loadConfig } from "./config.js";
+let lang;
+export function setLang(l) {
+    lang = l;
+}
+export function currentLang() {
+    if (lang)
+        return lang;
+    const fromEnv = envVar("LANG");
+    if (fromEnv === "en" || fromEnv === "vi")
+        return fromEnv;
+    try {
+        const c = loadConfig().lang;
+        if (c)
+            return c;
+    }
+    catch {
+        // unreadable config falls back to the system locale
+    }
+    const sys = process.env.LC_ALL ?? process.env.LC_MESSAGES ?? process.env.LANG ?? "";
+    return sys.toLowerCase().startsWith("en") ? "en" : "vi";
+}
+const vi = {
+    "auth.notLoggedIn": "Chưa đăng nhập.",
+    "auth.notLoggedIn.hint": "Chạy `{bin} login` (hoặc đặt {prefix}_API_KEY cho CI).",
+    "auth.expired": "Phiên trên máy này đã hết.",
+    "auth.expired.hint": "Đăng nhập lại: `{bin} login`",
+    "auth.revoked": "Phiên trên máy này đã bị đăng xuất (từ web hoặc quản trị).",
+    "auth.clock": "Đồng hồ máy lệch {min} phút so với máy chủ, token bị coi là sai.",
+    "auth.clock.hint": "Bật đồng bộ giờ rồi thử lại (`{bin} doctor`).",
+    "auth.apiKeyNoChat": "Khoá API không dùng được chế độ chat AI (đó là danh tính agent, không phải người).",
+    "auth.apiKeyNoChat.hint": "Dùng `{bin} tools call …`, hoặc `{bin} login --ci` trong CI.",
+    "net.failed": "Không kết nối được tới {host}.",
+    "net.failed.hint": "Kiểm mạng, proxy (HTTPS_PROXY) hoặc chạy `{bin} doctor`.",
+    "net.tls": "Không tin được chứng chỉ của máy chủ (có thể do proxy công ty).",
+    "net.tls.hint": "Đặt NODE_EXTRA_CA_CERTS=<tệp CA> hoặc HTTPS_PROXY=…",
+    "http.forbidden": "Không đủ quyền.",
+    "http.notFound": "Không tìm thấy.",
+    "http.rateLimited": "Hỏi nhanh quá, thử lại sau {sec} giây.",
+    "http.server": "{name} đang lỗi (mã yêu cầu {rid}).",
+    "http.server.hint": "Thử lại sau, hoặc `/support` kèm mã này.",
+    "http.tooOld": "Bản {cur} đã cũ, máy chủ cần ≥ {min}.",
+    "http.tooOld.hint": "Chạy `{bin} update`.",
+    "ws.gone": "Bạn không còn ở workspace này, hoặc workspace đang tạm khoá.",
+    "ws.gone.hint": "`{bin} workspace list`",
+    "ws.none": "Tài khoản chưa có công ty nào.",
+    "ws.none.hint": "Tạo tại {app} rồi chạy lại `{bin} login`.",
+    "keychain.fallback": "Không có Keychain. Token lưu tại {file} (chỉ bạn đọc được).",
+    "interrupted": "Đã huỷ.",
+};
+const en = {
+    "auth.notLoggedIn": "Not logged in.",
+    "auth.notLoggedIn.hint": "Run `{bin} login` (or set {prefix}_API_KEY in CI).",
+    "auth.expired": "Your session on this machine has expired.",
+    "auth.expired.hint": "Log in again: `{bin} login`",
+    "auth.revoked": "This machine was signed out (from the web or by an admin).",
+    "auth.clock": "Your clock is {min} minutes off from the server, so tokens look invalid.",
+    "auth.clock.hint": "Turn on automatic time sync and retry (`{bin} doctor`).",
+    "auth.apiKeyNoChat": "API keys cannot use AI chat (an API key is an agent identity, not a person).",
+    "auth.apiKeyNoChat.hint": "Use `{bin} tools call …`, or `{bin} login --ci` in CI.",
+    "net.failed": "Cannot reach {host}.",
+    "net.failed.hint": "Check your network, proxy (HTTPS_PROXY) or run `{bin} doctor`.",
+    "net.tls": "The server certificate is not trusted (often a corporate proxy).",
+    "net.tls.hint": "Set NODE_EXTRA_CA_CERTS=<ca file> or HTTPS_PROXY=…",
+    "http.forbidden": "Permission denied.",
+    "http.notFound": "Not found.",
+    "http.rateLimited": "Too many requests, retry in {sec} seconds.",
+    "http.server": "{name} returned an error (request id {rid}).",
+    "http.server.hint": "Try again later, or `/support` with this id.",
+    "http.tooOld": "Version {cur} is too old, the server needs ≥ {min}.",
+    "http.tooOld.hint": "Run `{bin} update`.",
+    "ws.gone": "You are no longer in this workspace, or it is suspended.",
+    "ws.gone.hint": "`{bin} workspace list`",
+    "ws.none": "Your account has no company yet.",
+    "ws.none.hint": "Create one at {app}, then run `{bin} login` again.",
+    "keychain.fallback": "No system keychain. Tokens are stored in {file} (readable only by you).",
+    "interrupted": "Cancelled.",
+};
+export function t(key, vars = {}) {
+    const dict = currentLang() === "en" ? en : vi;
+    const b = brand();
+    const all = { bin: b.bin, prefix: b.envPrefix, name: b.name, ...vars };
+    return (dict[key] ?? vi[key] ?? key).replace(/\{(\w+)\}/g, (_, k) => String(all[k] ?? `{${k}}`));
+}
+/** Inline bilingual helper for one-off strings: tr("Đã lưu", "Saved"). */
+export function tr(viText, enText) {
+    return currentLang() === "en" ? enText : viText;
+}

package/dist/core/lock.js

@@ -0,0 +1,44 @@
+// Cross-process lock around token refresh. The server already tolerates concurrent refreshes of the same
+// token (30 s grace + 7 day previous-token window), so this only avoids redundant calls: the process that
+// waits re-reads the stored session instead of refreshing again.
+import { openSync, closeSync, unlinkSync, statSync, writeSync } from "node:fs";
+import { setTimeout as sleep } from "node:timers/promises";
+const STALE_MS = 30_000;
+export async function withFileLock(path, fn, timeoutMs = 20_000) {
+    const started = Date.now();
+    let fd;
+    while (fd === undefined) {
+        try {
+            fd = openSync(path, "wx", 0o600);
+            writeSync(fd, String(process.pid));
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+            try {
+                if (Date.now() - statSync(path).mtimeMs > STALE_MS)
+                    unlinkSync(path);
+            }
+            catch {
+                // removed by the holder meanwhile
+            }
+            if (Date.now() - started > timeoutMs)
+                break;
+            await sleep(100);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        if (fd !== undefined) {
+            closeSync(fd);
+            try {
+                unlinkSync(path);
+            }
+            catch {
+                // already removed
+            }
+        }
+    }
+}

package/dist/core/output.js

@@ -0,0 +1,74 @@
+// Plain (non-Ink) output for subcommands. Colors follow NO_COLOR / --no-color / non-TTY.
+import { stdout, stderr } from "node:process";
+let colorOn = stdout.isTTY === true && !process.env.NO_COLOR;
+let quiet = false;
+let format = "text";
+export function setOutput(opts) {
+    if (opts.color === false)
+        colorOn = false;
+    if (opts.quiet !== undefined)
+        quiet = opts.quiet;
+    if (opts.format)
+        format = opts.format;
+}
+export const outputFormat = () => format;
+export const isJson = () => format !== "text";
+const wrap = (open, close) => (s) => (colorOn ? `\u001b[${open}m${s}\u001b[${close}m` : s);
+export const c = {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    cyan: wrap(36, 39),
+};
+export function info(line = "") {
+    if (!quiet && !isJson())
+        stdout.write(`${line}\n`);
+}
+export function ok(line) {
+    if (!quiet && !isJson())
+        stdout.write(`${c.green("✓")} ${line}\n`);
+}
+export function warn(line) {
+    stderr.write(`${c.yellow("⚠")} ${line}\n`);
+}
+export function fail(line, hint) {
+    stderr.write(`${c.red("✗")} ${line}\n`);
+    if (hint)
+        stderr.write(`  ${c.dim(hint)}\n`);
+}
+/** Drops null/undefined fields so JSON output stays readable; arrays keep their length. */
+export function compact(v) {
+    if (Array.isArray(v))
+        return v.map(compact);
+    if (v && typeof v === "object")
+        return Object.fromEntries(Object.entries(v).filter(([, x]) => x !== null && x !== undefined).map(([k, x]) => [k, compact(x)]));
+    return v;
+}
+export function json(value) {
+    stdout.write(`${JSON.stringify(compact(value), null, format === "json" ? 2 : 0)}\n`);
+}
+/** Prints `value` as JSON in json mode, otherwise calls `text`. */
+export function emit(value, text) {
+    if (isJson())
+        json(value);
+    else
+        text();
+}
+const width = (s) => [...s.replace(/\u001b\[[0-9;]*m/g, "")].length;
+/** Simple aligned table with box borders, used for list commands. */
+export function table(headers, rows, align = []) {
+    const cells = rows.map((r) => r.map((v) => (v === null || v === undefined ? "" : String(v))));
+    const w = headers.map((h, i) => Math.max(width(h), ...cells.map((r) => width(r[i] ?? ""))));
+    const pad = (s, i) => {
+        const n = (w[i] ?? 0) - width(s);
+        return align[i] === "r" ? " ".repeat(n) + s : s + " ".repeat(n);
+    };
+    const line = (l, m, r) => l + w.map((n) => "─".repeat(n + 2)).join(m) + r;
+    const row = (r) => "│" + r.map((s, i) => ` ${pad(s, i)} `).join("│") + "│";
+    return [line("┌", "┬", "┐"), row(headers.map((h) => c.bold(h))), line("├", "┼", "┤"), ...cells.map(row), line("└", "┴", "┘")].join("\n");
+}
+export function money(n) {
+    return new Intl.NumberFormat("vi-VN").format(n);
+}

package/dist/core/paths.js

@@ -0,0 +1,29 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+import { brand } from "./brand.js";
+function base(kind) {
+    const b = brand().bin;
+    if (process.platform === "win32") {
+        const root = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+        return join(root, b, kind === "state" ? "state" : "");
+    }
+    if (kind === "config")
+        return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), b);
+    return join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), b);
+}
+export function configDir() {
+    const d = base("config");
+    mkdirSync(d, { recursive: true, mode: 0o700 });
+    return d;
+}
+export function stateDir() {
+    const d = base("state");
+    mkdirSync(d, { recursive: true, mode: 0o700 });
+    return d;
+}
+export const configFile = () => join(configDir(), "config.toml");
+export const credentialsFile = () => join(configDir(), "credentials.json");
+export const historyFile = () => join(stateDir(), "history");
+export const lockFile = (profile) => join(stateDir(), `${profile}.lock`);
+export const updateCheckFile = () => join(stateDir(), "update-check.json");

package/dist/core/prompt.js

@@ -0,0 +1,137 @@
+// Minimal prompts for subcommands (the REPL has its own Ink components). All prompts refuse to run
+// without a TTY so scripts never hang waiting for input.
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { stdin, stderr } from "node:process";
+import { CliError, Exit } from "./errors.js";
+import { c } from "./output.js";
+import { t, tr } from "./i18n.js";
+export const hasTty = () => stdin.isTTY === true && stderr.isTTY === true;
+function needTty() {
+    if (!hasTty())
+        throw new CliError(tr("Cần terminal tương tác cho bước này.", "This step needs an interactive terminal."), Exit.usage);
+}
+export async function ask(question, signal) {
+    needTty();
+    const rl = createInterface({ input: stdin, output: stderr });
+    try {
+        return (await rl.question(question, signal ? { signal } : {})).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** [y/N] — anything but y/yes/có/c is no. Ctrl+C = no. */
+export async function confirm(question) {
+    needTty();
+    try {
+        const a = (await ask(`${question} ${c.bold("[y/N]")} `)).toLowerCase();
+        return a === "y" || a === "yes" || a === "c" || a === "có" || a === "co";
+    }
+    catch {
+        return false;
+    }
+}
+/** Typed confirmation for large writes: the user must type `expected` exactly. */
+export async function confirmTyped(question, expected) {
+    needTty();
+    const a = await ask(`${question} ${tr("Gõ", "Type")} ${c.bold(expected)} ${tr("để xác nhận, Enter để huỷ", "to confirm, Enter to cancel")} › `);
+    return a === expected;
+}
+/** Arrow-key single select. Returns undefined on Esc / Ctrl+C. */
+export async function select(title, choices, initial = 0) {
+    needTty();
+    if (choices.length === 0)
+        return undefined;
+    let i = Math.min(initial, choices.length - 1);
+    const out = stderr;
+    emitKeypressEvents(stdin);
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    const draw = (first) => {
+        if (!first)
+            out.write(`\u001b[${choices.length}A`);
+        choices.forEach((ch, k) => {
+            const mark = k === i ? c.cyan("❯ ") : "  ";
+            const label = k === i ? c.cyan(ch.label) : ch.label;
+            out.write(`\u001b[2K${mark}${label}${ch.hint ? "  " + c.dim(ch.hint) : ""}\n`);
+        });
+    };
+    out.write(`${title}\n`);
+    draw(true);
+    return new Promise((resolve) => {
+        const done = (v) => {
+            stdin.off("keypress", onKey);
+            stdin.setRawMode(wasRaw);
+            stdin.pause();
+            resolve(v);
+        };
+        const onKey = (_, key) => {
+            if (key.ctrl && key.name === "c")
+                return done(undefined);
+            if (key.name === "escape")
+                return done(undefined);
+            if (key.name === "up" || key.name === "k")
+                i = (i - 1 + choices.length) % choices.length;
+            else if (key.name === "down" || key.name === "j")
+                i = (i + 1) % choices.length;
+            else if (key.name === "return")
+                return done(choices[i].value);
+            else
+                return;
+            draw(false);
+        };
+        stdin.on("keypress", onKey);
+    });
+}
+/** Multi select with space; Enter accepts. */
+export async function multiSelect(title, choices) {
+    needTty();
+    let i = 0;
+    const on = new Set();
+    const out = stderr;
+    emitKeypressEvents(stdin);
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    const draw = (first) => {
+        if (!first)
+            out.write(`\u001b[${choices.length + 1}A`);
+        choices.forEach((ch, k) => {
+            const box = on.has(k) ? c.green("◼") : "◻";
+            const label = k === i ? c.cyan(ch.label) : ch.label;
+            out.write(`\u001b[2K${k === i ? c.cyan("❯ ") : "  "}${box} ${label}${ch.hint ? "  " + c.dim(ch.hint) : ""}\n`);
+        });
+        out.write(`\u001b[2K${c.dim(tr("  Space chọn · Enter xong · Esc huỷ", "  Space toggle · Enter accept · Esc cancel"))}\n`);
+    };
+    out.write(`${title}\n`);
+    draw(true);
+    return new Promise((resolve) => {
+        const done = (v) => {
+            stdin.off("keypress", onKey);
+            stdin.setRawMode(wasRaw);
+            stdin.pause();
+            resolve(v);
+        };
+        const onKey = (_, key) => {
+            if ((key.ctrl && key.name === "c") || key.name === "escape")
+                return done(undefined);
+            if (key.name === "up")
+                i = (i - 1 + choices.length) % choices.length;
+            else if (key.name === "down")
+                i = (i + 1) % choices.length;
+            else if (key.name === "space")
+                on.has(i) ? on.delete(i) : on.add(i);
+            else if (key.name === "return")
+                return done([...on].sort().map((k) => choices[k].value));
+            else
+                return;
+            draw(false);
+        };
+        stdin.on("keypress", onKey);
+    });
+}
+export function interrupted() {
+    return new CliError(t("interrupted"), Exit.interrupted);
+}

package/dist/core/version.js

@@ -0,0 +1,13 @@
+// Standalone binaries get the version injected at build time (--define __CLI_VERSION__); npm installs read package.json.
+import { createRequire } from "node:module";
+function read() {
+    if (typeof __CLI_VERSION__ === "string")
+        return __CLI_VERSION__;
+    try {
+        return createRequire(import.meta.url)("../../package.json").version;
+    }
+    catch {
+        return "0.0.0-dev";
+    }
+}
+export const VERSION = read();

package/dist/main.js

@@ -0,0 +1,38 @@
+import { buildProgram } from "./program.js";
+import { CliError, Exit, isCliError } from "./core/errors.js";
+import { fail, isJson } from "./core/output.js";
+import { maybeNotifyUpdate } from "./commands/util.js";
+import { setLang } from "./core/i18n.js";
+import { envVar } from "./core/brand.js";
+export async function main(argv) {
+    // Help text is built before flags are parsed, so honour --lang early.
+    const li = argv.indexOf("--lang");
+    const early = li > 0 ? argv[li + 1] : argv.find((a) => a.startsWith("--lang="))?.slice(7);
+    if (early === "en" || early === "vi")
+        setLang(early);
+    const program = buildProgram();
+    program.exitOverride();
+    try {
+        await program.parseAsync(argv);
+        await maybeNotifyUpdate();
+    }
+    catch (e) {
+        process.exitCode = report(e);
+    }
+}
+function report(e) {
+    const err = e;
+    // commander: --help / --version / usage errors
+    if (err?.code === "commander.helpDisplayed" || err?.code === "commander.version" || err?.code === "commander.help")
+        return Exit.ok;
+    if (typeof err?.code === "string" && err.code.startsWith("commander."))
+        return Exit.usage;
+    const ce = isCliError(e) ? e : new CliError(e?.message ?? String(e), Exit.general);
+    if (isJson())
+        process.stderr.write(`${JSON.stringify({ error: { message: ce.message, hint: ce.hint, exitCode: ce.exitCode, requestId: ce.requestId } })}\n`);
+    else
+        fail(ce.message + (ce.requestId && !ce.message.includes(ce.requestId) ? ` (${ce.requestId})` : ""), ce.hint);
+    if (envVar("DEBUG") === "1" && !isCliError(e))
+        console.error(e);
+    return ce.exitCode;
+}

package/dist/mcp/client.js

@@ -0,0 +1,114 @@
+// Minimal MCP client over Streamable HTTP (JSON-RPC 2.0): initialize, tools/list, tools/call.
+// Responses may arrive as JSON or as an SSE stream carrying the JSON-RPC message.
+import { fetch } from "undici";
+import { context } from "../core/context.js";
+import { CliError, Exit } from "../core/errors.js";
+import { tr } from "../core/i18n.js";
+import { errorFor, networkError, userAgent } from "../core/http.js";
+import { VERSION } from "../core/version.js";
+import { brand } from "../core/brand.js";
+import { mcpToken, deleteGrant } from "../auth/mcp-oauth.js";
+const PROTOCOL = "2025-06-18";
+export class McpClient {
+    interactive;
+    apiKey;
+    sessionId;
+    nextId = 1;
+    token;
+    ready = false;
+    constructor(interactive, apiKey) {
+        this.interactive = interactive;
+        this.apiKey = apiKey;
+    }
+    async rpc(method, params, notification = false) {
+        const url = context().endpoints.mcp;
+        this.token ??= this.apiKey ?? (await mcpToken({ interactive: this.interactive }));
+        const id = notification ? undefined : this.nextId++;
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            "User-Agent": userAgent(),
+            "MCP-Protocol-Version": PROTOCOL,
+            Authorization: `Bearer ${this.token}`,
+        };
+        if (this.sessionId)
+            headers["Mcp-Session-Id"] = this.sessionId;
+        let res;
+        try {
+            res = await fetch(url, { method: "POST", headers, body: JSON.stringify({ jsonrpc: "2.0", ...(id ? { id } : {}), method, ...(params ? { params } : {}) }) });
+        }
+        catch (e) {
+            throw networkError(e, url);
+        }
+        if (res.status === 401 && !this.apiKey) {
+            // Grant revoked or scopes changed: drop it so the next run asks again.
+            deleteGrant();
+            throw new CliError(tr("Quyền công cụ AI của CLI đã hết hoặc bị thu hồi.", "The CLI's AI tool access expired or was revoked."), Exit.auth, `${brand().bin} tools login`);
+        }
+        const sid = res.headers.get("mcp-session-id");
+        if (sid)
+            this.sessionId = sid;
+        if (notification) {
+            await res.body?.cancel();
+            return undefined;
+        }
+        const ct = res.headers.get("content-type") ?? "";
+        let msg;
+        if (ct.includes("text/event-stream")) {
+            const text = await res.text();
+            for (const frame of text.split("\n\n")) {
+                const data = frame.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+                if (!data)
+                    continue;
+                const m = JSON.parse(data);
+                if (m.id === id)
+                    msg = m;
+            }
+        }
+        else {
+            const body = await res.json().catch(() => undefined);
+            if (!res.ok)
+                throw errorFor(res.status, body, res);
+            msg = body;
+        }
+        if (!msg)
+            throw new CliError(tr("Máy chủ MCP không trả lời.", "The MCP server did not answer."), Exit.general);
+        if (msg.error)
+            throw new CliError(msg.error.message, msg.error.code === -32602 ? Exit.usage : Exit.general);
+        return msg.result;
+    }
+    async init() {
+        if (this.ready)
+            return;
+        await this.rpc("initialize", { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: `${brand().bin}-cli`, version: VERSION } });
+        await this.rpc("notifications/initialized", undefined, true);
+        this.ready = true;
+    }
+    async listTools() {
+        await this.init();
+        const all = [];
+        let cursor;
+        do {
+            const r = await this.rpc("tools/list", cursor ? { cursor } : {});
+            all.push(...r.tools);
+            cursor = r.nextCursor;
+        } while (cursor);
+        return all;
+    }
+    async callTool(name, args) {
+        await this.init();
+        return this.rpc("tools/call", { name, arguments: args });
+    }
+}
+/** Joins text content of a tool result; parses JSON when the text is JSON. */
+export function resultValue(r) {
+    if (r.structuredContent !== undefined)
+        return r.structuredContent;
+    const text = (r.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n");
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/dist/program.js

@@ -0,0 +1,102 @@
+import { Command, Option } from "commander";
+import { brand } from "./core/brand.js";
+import { initContext } from "./core/context.js";
+import { setOutput } from "./core/output.js";
+import { setLang } from "./core/i18n.js";
+import { VERSION } from "./core/version.js";
+import { tr } from "./core/i18n.js";
+import { registerAuth } from "./commands/auth.js";
+import { registerWorkspace } from "./commands/workspace.js";
+import { registerAi, runRoot } from "./commands/ai.js";
+import { registerTools } from "./commands/tools.js";
+import { registerApi } from "./commands/api.js";
+import { registerKeys } from "./commands/keys.js";
+import { registerWebhooks } from "./commands/webhooks.js";
+import { registerDocs } from "./commands/docs.js";
+import { registerMcp } from "./commands/mcp.js";
+import { registerUtil } from "./commands/util.js";
+import { registerHelp } from "./commands/help.js";
+const collect = (v, prev = []) => [...prev, v];
+export function buildProgram() {
+    const b = brand();
+    const program = new Command(b.bin)
+        .description(tr(`${b.aiName} và công cụ nhà phát triển trong terminal`, `${b.aiName} and developer tools in your terminal`))
+        .version(VERSION, "-v, --version", tr("in phiên bản", "print the version"))
+        .helpOption("-h, --help", tr("trợ giúp", "show help"))
+        .argument("[question...]", tr("câu hỏi gửi ngay khi mở chat", "question to send when chat opens"))
+        .option("-p, --print [question]", tr("không tương tác: in câu trả lời rồi thoát (đọc thêm từ stdin)", "non-interactive: print the answer and exit (reads stdin too)"))
+        .option("-c, --continue", tr("nối hội thoại gần nhất", "continue the last conversation"))
+        .option("-r, --resume [id]", tr("mở lại hội thoại cũ (không id = chọn trong danh sách)", "resume a conversation (no id = pick from a list)"))
+        .option("-f, --file <path>", tr("đính kèm tệp Excel/CSV, ảnh hoặc tệp chữ (lặp được, tối đa 3)", "attach an Excel/CSV, image or text file (repeatable, max 3)"), collect)
+        .addOption(new Option("--profile <name>", tr("hồ sơ đăng nhập", "login profile")))
+        .option("--sandbox", tr("dùng môi trường thử nghiệm", "use the sandbox environment"))
+        .option("-w, --workspace <code>", tr("chạy lệnh này trên workspace khác", "run this command on another workspace"))
+        .option("--agent <code>", tr("chọn Agent thay cho Trợ lý chung", "choose an Agent instead of the general assistant"))
+        .addOption(new Option("--mode <mode>", tr("chế độ quyền", "permission mode")).choices(["read", "propose", "auto"]))
+        .addOption(new Option("--output-format <format>", tr("định dạng đầu ra", "output format")).choices(["text", "json", "stream-json"]))
+        .option("--json", tr("viết tắt của --output-format json", "shorthand for --output-format json"))
+        .addOption(new Option("--lang <lang>", tr("ngôn ngữ", "language")).choices(["vi", "en"]))
+        .option("--no-color", tr("tắt màu", "disable colors"))
+        .option("--quiet", tr("chỉ in kết quả", "print results only"))
+        .option("--verbose", tr("in chi tiết", "verbose output"))
+        .option("--debug", tr("in request-id và thời gian từng cửa (không in token)", "print request ids and timings (never tokens)"))
+        .enablePositionalOptions()
+        .showSuggestionAfterError(true)
+        .configureHelp({ sortSubcommands: false, showGlobalOptions: true });
+    program.hook("preAction", (_this, action) => {
+        // Global flags work before or after the subcommand: `nextx --sandbox login` and `nextx login --sandbox`.
+        const o = { ...program.opts(), ...pickGlobals(action.opts()) };
+        setLang(o.lang);
+        setOutput({ color: o.color, quiet: o.quiet, format: o.json ? "json" : o.outputFormat });
+        initContext(o);
+    });
+    program.action(async (question) => runRoot(program.opts(), question));
+    registerAuth(program);
+    registerWorkspace(program);
+    registerAi(program);
+    registerTools(program);
+    registerApi(program);
+    registerKeys(program);
+    registerWebhooks(program);
+    registerDocs(program);
+    registerMcp(program);
+    registerUtil(program);
+    registerHelp(program);
+    for (const sub of program.commands)
+        addGlobals(sub);
+    return program;
+}
+/** Flags every subcommand accepts too (hidden in its help; listed once under the root). `-f` stays root-only: `api -f` means a field. */
+const GLOBALS = [
+    ["--profile <name>", "profile"],
+    ["--sandbox", "sandbox"],
+    ["-w, --workspace <code>", "workspace"],
+    ["--agent <code>", "agent"],
+    ["--mode <mode>", "mode", ["read", "propose", "auto"]],
+    ["--output-format <format>", "outputFormat", ["text", "json", "stream-json"]],
+    ["--json", "json"],
+    ["--lang <lang>", "lang", ["vi", "en"]],
+    ["--no-color", "color"],
+    ["--quiet", "quiet"],
+    ["--verbose", "verbose"],
+    ["--debug", "debug"],
+];
+function addGlobals(cmd) {
+    for (const [flags, , choices] of GLOBALS) {
+        const o = new Option(flags).hideHelp();
+        if (choices)
+            o.choices(choices);
+        const taken = cmd.options.some((x) => x.long === o.long || (o.short && x.short === o.short));
+        if (!taken)
+            cmd.addOption(o);
+    }
+    for (const sub of cmd.commands)
+        addGlobals(sub);
+}
+function pickGlobals(o) {
+    const out = {};
+    for (const [, key] of GLOBALS)
+        if (o[key] !== undefined && !(key === "color" && o[key] === true))
+            out[key] = o[key];
+    return out;
+}