@nextxai/cli 0.0.0-stage → 0.1.1

package/dist/commands/tools.js

@@ -0,0 +1,186 @@
+import { Option } from "commander";
+import { readFileSync } from "node:fs";
+import { brand, envVar } from "../core/brand.js";
+import { CliError, Exit } from "../core/errors.js";
+import { currentLang, tr } from "../core/i18n.js";
+import { c, emit, info, json, ok, table } from "../core/output.js";
+import { get, post } from "../core/http.js";
+import { hasTty } from "../core/prompt.js";
+import { McpClient, resultValue } from "../mcp/client.js";
+import { authorizeMcp, readGrant, revokeGrant } from "../auth/mcp-oauth.js";
+import { browserAvailable } from "./auth.js";
+let publicCache;
+export async function publicTools() {
+    publicCache ??= (await get("/ai/public/tools", { anonymous: true })).filter((t) => !brand().modules || brand().modules.includes(t.module));
+    return publicCache;
+}
+/** MCP names may differ from catalog names (module prefix, dots); match loosely. */
+export function sameTool(a, b) {
+    const n = (s) => s.toLowerCase().replace(/[.\-]/g, "_");
+    return n(a) === n(b) || n(a).endsWith(`_${n(b)}`) || n(b).endsWith(`_${n(a)}`);
+}
+/** `raw` keeps every value a string (api -f); otherwise numbers/booleans/JSON are inferred, but never for values with a leading zero (phone numbers, codes). */
+export function parseArgs(o) {
+    let base = {};
+    try {
+        if (o.argsFile)
+            base = JSON.parse(readFileSync(o.argsFile === "-" ? 0 : o.argsFile, "utf8"));
+        if (o.args)
+            base = { ...base, ...JSON.parse(o.args) };
+    }
+    catch (e) {
+        throw new CliError(tr(`Tham số không phải JSON hợp lệ: ${e.message}`, `Arguments are not valid JSON: ${e.message}`), Exit.usage);
+    }
+    for (const kv of o.raw ?? []) {
+        const i = kv.indexOf("=");
+        if (i < 1)
+            throw new CliError(tr(`-f cần dạng khoá=giá_trị: ${kv}`, `-f needs key=value: ${kv}`), Exit.usage);
+        base[kv.slice(0, i)] = kv.slice(i + 1);
+    }
+    for (const kv of o.arg ?? []) {
+        const i = kv.indexOf("=");
+        if (i < 1)
+            throw new CliError(tr(`-a cần dạng khoá=giá_trị: ${kv}`, `-a needs key=value: ${kv}`), Exit.usage);
+        const k = kv.slice(0, i);
+        const raw = kv.slice(i + 1);
+        let v = raw;
+        if (/^-?(0|[1-9]\d*)(\.\d+)?$/.test(raw) && raw.length < 16)
+            v = Number(raw);
+        else if (raw === "true" || raw === "false")
+            v = raw === "true";
+        else if (/^[[{]/.test(raw)) {
+            try {
+                v = JSON.parse(raw);
+            }
+            catch {
+                // keep as string
+            }
+        }
+        base[k] = v;
+    }
+    return base;
+}
+const summaryOf = (t) => (t ? (currentLang() === "en" ? t.summaryEn ?? t.summary : t.summary) ?? "" : "");
+function mergeList(mcp, pub) {
+    return mcp.map((m) => {
+        const p = pub.find((x) => sameTool(x.name, m.name));
+        return {
+            name: m.name,
+            module: p?.module ?? m.name.split(/[_.]/)[0] ?? "",
+            title: p?.title ?? m.title ?? m.annotations?.title ?? m.name,
+            kind: p?.kind ?? (m.annotations?.readOnlyHint ? "read" : "proposal"),
+            summary: summaryOf(p) || (m.description ?? "").split("\n")[0],
+        };
+    });
+}
+export function registerTools(program) {
+    const tools = program.command("tools").description(tr("công cụ AI bạn được dùng (theo quyền thật)", "AI tools you can use (by your real permissions)"));
+    tools.command("login")
+        .description(tr("cấp quyền công cụ AI cho CLI trên máy này (một lần)", "grant AI tool access to the CLI on this machine (once)"))
+        .option("--no-browser", tr("không tự mở trình duyệt", "do not open the browser"))
+        .action(async (o) => {
+        const g = await authorizeMcp({ openBrowser: o.browser !== false && browserAvailable(), manual: o.browser === false || !browserAvailable() });
+        emit({ scope: g.scope.split(" ") }, () => ok(tr(`Đã cấp quyền: ${g.scope}`, `Granted: ${g.scope}`)));
+    });
+    tools.command("logout").description(tr("thu hồi quyền công cụ AI của CLI", "revoke the CLI's AI tool access"))
+        .action(async () => {
+        await revokeGrant();
+        ok(tr("Đã thu hồi.", "Revoked."));
+    });
+    tools.command("list", { isDefault: true })
+        .description(tr("danh sách công cụ", "list tools"))
+        .option("--module <m>", tr("lọc theo phân hệ (crm, sales, gym…)", "filter by module (crm, sales, gym…)"))
+        .addOption(new Option("--kind <k>", tr("lọc theo loại", "filter by kind")).choices(["read", "proposal", "export"]))
+        .option("--public", tr("danh mục công khai (không cần đăng nhập)", "public catalog (no login)"))
+        .action(async (o) => {
+        const pub = await publicTools();
+        let rows;
+        if (o.public || envVar("API_KEY")) {
+            rows = pub.map((p) => ({ name: p.name, module: p.module, title: p.title ?? p.name, kind: p.kind ?? "", summary: summaryOf(p) }));
+            if (envVar("API_KEY"))
+                rows = rows.filter((r) => r.kind === "read");
+        }
+        else {
+            const mcp = await new McpClient(hasTty()).listTools();
+            rows = mergeList(mcp, pub);
+        }
+        if (o.module)
+            rows = rows.filter((r) => r.module === o.module);
+        if (o.kind)
+            rows = rows.filter((r) => r.kind === o.kind);
+        emit(rows, () => {
+            info(table([tr("Công cụ", "Tool"), tr("Phân hệ", "Module"), tr("Loại", "Kind"), tr("Mô tả", "Summary")], rows.map((r) => [r.name, r.module, r.kind === "read" ? r.kind : c.yellow(r.kind), r.summary.slice(0, 70)])));
+            info(c.dim(`  ${rows.length} ${tr("công cụ", "tools")} · ${brand().bin} tools describe <${tr("tên", "name")}>`));
+        });
+    });
+    tools.command("describe <name>")
+        .description(tr("tham số và ví dụ của một công cụ", "parameters and an example for a tool"))
+        .action(async (name) => {
+        const pub = (await publicTools()).find((p) => sameTool(p.name, name));
+        let schema = pub?.parameters;
+        if (!pub && !envVar("API_KEY") && readGrant()) {
+            const m = (await new McpClient(false).listTools()).find((t) => sameTool(t.name, name));
+            schema = m?.inputSchema;
+            if (!m)
+                throw new CliError(tr("Không thấy công cụ này.", "Tool not found."), Exit.notFound);
+        }
+        else if (!pub)
+            throw new CliError(tr("Không thấy công cụ này.", "Tool not found."), Exit.notFound);
+        emit({ ...pub, parameters: schema }, () => {
+            info(`${c.bold(pub?.title ?? name)} ${c.dim(`${pub?.module ?? ""} · ${pub?.kind ?? ""} · ${pub?.scope ?? ""}`)}`);
+            if (pub)
+                info(summaryOf(pub));
+            const props = (schema?.properties ?? {});
+            const req = new Set(schema?.required ?? []);
+            if (Object.keys(props).length) {
+                info();
+                info(table([tr("Tham số", "Param"), tr("Kiểu", "Type"), "", tr("Mô tả", "Description")], Object.entries(props).map(([k, v]) => [
+                    k, v.enum ? v.enum.join("|") : (v.type ?? ""), req.has(k) ? tr("bắt buộc", "required") : "", (currentLang() === "en" ? v["x-description-en"] ?? v.description : v.description) ?? "",
+                ])));
+            }
+            const ex = pub?.exampleArgs ?? Object.fromEntries([...req].map((k) => [k, `<${k}>`]));
+            info();
+            info(c.dim(`  ${brand().bin} tools call ${name} --args '${JSON.stringify(ex)}'`));
+        });
+    });
+    tools.command("call <name>")
+        .description(tr("gọi một công cụ. Công cụ ghi chỉ tạo đề xuất để xác nhận", "call a tool. Write tools only create a proposal to confirm"))
+        .option("--args <json>", tr("tham số JSON", "JSON arguments"))
+        .option("--args-file <file>", tr("tham số từ tệp JSON (- = stdin)", "arguments from a JSON file (- = stdin)"))
+        .option("-a, --arg <key=value>", tr("một tham số (lặp được)", "one argument (repeatable)"), (v, p = []) => [...p, v])
+        .action(async (name, o) => {
+        const args = parseArgs(o);
+        let value;
+        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);
+            if (pub.kind !== "read")
+                throw new CliError(tr("Khoá API chỉ gọi được công cụ đọc.", "API keys can only call read tools."), Exit.forbidden);
+            value = await post(`/ai/tools/${pub.module}/${pub.name}/read`, args);
+        }
+        else {
+            const client = new McpClient(hasTty());
+            const tool = (await client.listTools()).find((t) => sameTool(t.name, name));
+            if (!tool)
+                throw new CliError(tr("Không thấy công cụ này trong quyền của bạn.", "This tool is not in your permissions."), Exit.notFound, `${brand().bin} tools list`);
+            const props = Object.keys(tool.inputSchema?.properties ?? {});
+            const wrapped = props.length === 1 && props[0] === "args" && !("args" in args) ? { args } : args;
+            const r = await client.callTool(tool.name, wrapped);
+            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;
+            }
+        }
+        const text = typeof value === "string" ? value : "";
+        const proposal = /xác nhận|confirm/i.test(text) && /https?:\/\//.test(text);
+        if (proposal)
+            process.exitCode = Exit.notConfirmed;
+        if (typeof value === "string")
+            emit({ result: value }, () => info(value));
+        else
+            json(value);
+    });
+}

package/dist/commands/util.js

@@ -0,0 +1,224 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fetch } from "undici";
+import { brand, envVar } from "../core/brand.js";
+import { context } from "../core/context.js";
+import { CliError, Exit } from "../core/errors.js";
+import { tr } from "../core/i18n.js";
+import { c, emit, info, isJson, ok } from "../core/output.js";
+import { loadConfig, saveConfig, SETTABLE, getProfile } from "../core/config.js";
+import { updateCheckFile } from "../core/paths.js";
+import { userAgent, isOlder } from "../core/http.js";
+import { VERSION } from "../core/version.js";
+import { storageKind } from "../auth/credentials.js";
+import { authSource, currentAuth } from "../auth/session.js";
+import { readGrant } from "../auth/mcp-oauth.js";
+import { notesFileName } from "./ai.js";
+async function timed(url, init) {
+    const t = Date.now();
+    const res = await fetch(url, { ...init, headers: { "User-Agent": userAgent(), ...init?.headers } });
+    return { res, ms: Date.now() - t };
+}
+export async function doctor() {
+    const ep = context().endpoints;
+    const checks = [];
+    const add = (name, ok, detail) => checks.push({ name, ok, detail });
+    for (const [label, url] of [["API", `${ep.api}/api/v1/iam/auth/me`], [tr("Đăng nhập", "Auth"), `${ep.auth}/.well-known/oauth-authorization-server`], ["MCP", `${new URL(ep.mcp).origin}/.well-known/oauth-protected-resource`]]) {
+        try {
+            const { res, ms } = await timed(url);
+            await res.body?.cancel();
+            add(label, res.status < 500, `${new URL(url).host} · HTTP ${res.status} · ${ms}ms`);
+            if (label === "API") {
+                const server = Date.parse(res.headers.get("date") ?? "");
+                if (server) {
+                    const skew = Math.round((Date.now() - server) / 1000);
+                    add(tr("Đồng hồ", "Clock"), Math.abs(skew) > 120 ? false : Math.abs(skew) > 30 ? "warn" : true, tr(`lệch ${skew}s so với máy chủ`, `${skew}s off from the server`));
+                }
+            }
+        }
+        catch (e) {
+            const code = e.cause?.code ?? e.message;
+            add(label, false, `${new URL(url).host} · ${code}`);
+        }
+    }
+    const proxy = process.env.HTTPS_PROXY ?? process.env.https_proxy;
+    if (proxy)
+        add("Proxy", true, proxy.replace(/\/\/[^@]*@/, "//***@"));
+    if (process.env.NODE_EXTRA_CA_CERTS)
+        add("CA", true, process.env.NODE_EXTRA_CA_CERTS);
+    const src = authSource();
+    if (src === "none")
+        add(tr("Danh tính", "Identity"), false, tr(`chưa đăng nhập · ${brand().bin} login`, `not logged in · ${brand().bin} login`));
+    else {
+        try {
+            await currentAuth({ required: true });
+            const { get } = await import("../core/http.js");
+            const me = await get("/iam/auth/me");
+            add(tr("Danh tính", "Identity"), true, `${src} · ${me.email ?? ""} · ${me.workspace?.name ?? ""} · ${me.permissions?.length ?? 0} ${tr("quyền", "permissions")}`);
+            try {
+                const u = await get("/operator/widget/support/usage");
+                add(tr("Gói AI", "AI plan"), u.limit === 0 ? "warn" : true, `${u.planName ?? "-"}${u.limit ? ` · ${tr("còn", "left")} ${u.remaining}/${u.limit}` : ""}`);
+            }
+            catch {
+                // API keys cannot read usage
+            }
+        }
+        catch (e) {
+            add(tr("Danh tính", "Identity"), false, e.message);
+        }
+    }
+    add(tr("Lưu token", "Token storage"), storageKind() === "keychain" ? true : "warn", storageKind() === "keychain" ? "Keychain" : tr("tệp 0600 (không có Keychain)", "0600 file (no keychain)"));
+    add(tr("Công cụ AI", "AI tools"), readGrant() ? true : "warn", readGrant() ? tr("đã cấp quyền", "granted") : tr(`chưa cấp · ${brand().bin} tools login`, `not granted · ${brand().bin} tools login`));
+    const latest = await latestVersion().catch(() => undefined);
+    add(tr("Phiên bản", "Version"), latest && isOlder(VERSION, latest) ? "warn" : true, latest && isOlder(VERSION, latest) ? `${VERSION} → ${latest} · ${brand().bin} update` : `${VERSION}${latest ? ` (${tr("mới nhất", "latest")})` : ""}`);
+    add("Node", Number(process.versions.node.split(".")[0]) >= 20, process.versions.node);
+    return checks;
+}
+// ── updates ────────────────────────────────────────────────────────────────────────────────────────
+async function latestVersion(channel = loadConfig().updateChannel ?? "latest") {
+    const res = await fetch(`https://registry.npmjs.org/${brand().pkg.replace("/", "%2f")}`, { headers: { Accept: "application/vnd.npm.install-v1+json" }, signal: AbortSignal.timeout(3000) });
+    if (!res.ok)
+        return undefined;
+    const body = (await res.json());
+    return body["dist-tags"]?.[channel === "next" ? "next" : "latest"];
+}
+export function installMethod() {
+    const script = process.argv[1] ?? "";
+    if (/Cellar|homebrew/i.test(script) || /Cellar|homebrew/i.test(process.execPath))
+        return "brew";
+    if (!/node(\.exe)?$/i.test(process.execPath) && !/bun/i.test(process.execPath))
+        return "standalone";
+    if (script.includes("node_modules"))
+        return "npm";
+    return "dev";
+}
+export async function maybeNotifyUpdate() {
+    if (isJson() || !process.stderr.isTTY || envVar("NO_UPDATE_CHECK") === "1" || loadConfig().updateCheck === false)
+        return;
+    const f = updateCheckFile();
+    let last = 0;
+    let latest;
+    try {
+        const s = JSON.parse(readFileSync(f, "utf8"));
+        last = s.at;
+        latest = s.latest;
+    }
+    catch {
+        // first run
+    }
+    if (Date.now() - last > 24 * 3600e3) {
+        latest = await latestVersion().catch(() => undefined);
+        writeFileSync(f, JSON.stringify({ at: Date.now(), latest }));
+    }
+    if (latest && isOlder(VERSION, latest))
+        process.stderr.write(c.dim(`\n${tr("Có bản mới", "Update available")} ${VERSION} → ${latest} · ${brand().bin} update\n`));
+}
+// ── completion ─────────────────────────────────────────────────────────────────────────────────────
+/** Candidates for the word being completed, walking the command tree. */
+export function completions(program, words) {
+    let cmd = program;
+    const done = words.slice(0, -1);
+    const cur = words[words.length - 1] ?? "";
+    for (const w of done) {
+        const sub = cmd.commands.find((s) => s.name() === w || s.aliases().includes(w));
+        if (sub)
+            cmd = sub;
+    }
+    const opts = [...cmd.options, ...(cmd === program ? [] : program.options)].flatMap((o) => [o.long, o.short]).filter(Boolean);
+    const subs = cmd.commands.filter((s) => !s.name().startsWith("__")).map((s) => s.name());
+    return (cur.startsWith("-") ? opts : subs).filter((x) => x.startsWith(cur));
+}
+function completionScript(shell) {
+    const b = brand().bin;
+    switch (shell) {
+        case "bash":
+            return `_${b}_complete() {\n  local IFS=$'\\n'\n  COMPREPLY=( $(${b} __complete "\${COMP_WORDS[@]:1:COMP_CWORD}") )\n}\ncomplete -o default -F _${b}_complete ${b}\n`;
+        case "zsh":
+            return `#compdef ${b}\n_${b}() {\n  local -a items\n  items=("\${(@f)$(${b} __complete "\${words[@]:1:CURRENT-1}")}")\n  compadd -a items\n}\ncompdef _${b} ${b}\n`;
+        case "fish":
+            return `complete -c ${b} -f -a '(${b} __complete (commandline -opc)[2..-1] (commandline -ct))'\n`;
+        case "powershell":
+            return `Register-ArgumentCompleter -Native -CommandName ${b} -ScriptBlock {\n  param($wordToComplete, $commandAst)\n  $words = $commandAst.CommandElements | Select-Object -Skip 1 | ForEach-Object { $_.ToString() }\n  if ($wordToComplete -eq '') { $words += '' }\n  & ${b} __complete @words | ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }\n}\n`;
+        default:
+            throw new CliError(tr("Shell: bash | zsh | fish | powershell", "Shell: bash | zsh | fish | powershell"), Exit.usage);
+    }
+}
+// ── register ───────────────────────────────────────────────────────────────────────────────────────
+export function registerUtil(program) {
+    const b = brand();
+    program.command("doctor").description(tr("kiểm kết nối, đồng hồ, token, gói, phiên bản", "check connectivity, clock, token, plan, version"))
+        .action(async () => {
+        const checks = await doctor();
+        emit(checks, () => {
+            for (const ch of checks)
+                info(`${ch.ok === true ? c.green("✓") : ch.ok === "warn" ? c.yellow("⚠") : c.red("✗")} ${ch.name.padEnd(14)} ${ch.detail}`);
+        });
+        if (checks.some((ch) => ch.ok === false))
+            process.exitCode = Exit.general;
+    });
+    const cfg = program.command("config").description(tr("cài đặt", "settings"));
+    cfg.command("list", { isDefault: true }).action(() => {
+        const c0 = loadConfig();
+        emit(c0, () => {
+            for (const k of Object.keys(SETTABLE))
+                info(`${k.padEnd(16)} ${String(c0[k] ?? c.dim("—"))}`);
+            info(c.dim(`${tr("hồ sơ", "profiles")}: ${Object.keys(c0.profiles).join(", ") || "—"}`));
+        });
+    });
+    cfg.command("get <key>").action((key) => info(String(loadConfig()[key] ?? "")));
+    cfg.command("set <key> <value>").description(Object.keys(SETTABLE).join(" · ")).action((key, value) => {
+        const parse = SETTABLE[key];
+        if (!parse)
+            throw new CliError(tr(`Không có cài đặt "${key}". Có: ${Object.keys(SETTABLE).join(", ")}`, `No setting "${key}". Available: ${Object.keys(SETTABLE).join(", ")}`), Exit.usage);
+        const c0 = loadConfig();
+        try {
+            c0[key] = parse(value);
+        }
+        catch (e) {
+            throw new CliError(e.message, Exit.usage);
+        }
+        saveConfig(c0);
+        ok(`${key} = ${String(c0[key])}`);
+    });
+    program.command("completion <shell>").description(tr("gợi ý Tab cho bash | zsh | fish | powershell", "Tab completion for bash | zsh | fish | powershell"))
+        .addHelpText("after", tr(`\nVí dụ: ${b.bin} completion zsh > ~/.zfunc/_${b.bin}`, `\nExample: ${b.bin} completion zsh > ~/.zfunc/_${b.bin}`))
+        .action((shell) => void process.stdout.write(completionScript(shell)));
+    program.command("__complete", { hidden: true }).argument("[words...]").allowUnknownOption(true).helpOption(false)
+        .action((words = []) => void process.stdout.write(completions(program, words.length ? words : [""]).join("\n")));
+    program.command("update").description(tr("nâng lên bản mới", "upgrade to the latest version"))
+        .option("--channel <c>", "latest | next")
+        .action(async (o) => {
+        const channel = o.channel ?? loadConfig().updateChannel ?? "latest";
+        const latest = await latestVersion(channel).catch(() => undefined);
+        if (latest && !isOlder(VERSION, latest))
+            return ok(tr(`Đang dùng bản mới nhất (${VERSION}).`, `Already up to date (${VERSION}).`));
+        const how = installMethod();
+        const cmds = {
+            npm: ["npm", ["install", "-g", `${b.pkg}@${channel}`]],
+            brew: ["brew", ["upgrade", b.bin]],
+        };
+        if (how === "standalone") {
+            info(tr(`Tải bản mới: curl -fsSL ${context().endpoints.docs}/install.sh | sh`, `Get the new build: curl -fsSL ${context().endpoints.docs}/install.sh | sh`));
+            return;
+        }
+        if (how === "dev")
+            return info(tr("Bản chạy từ mã nguồn, cập nhật bằng git pull.", "Running from source, update with git pull."));
+        const [cmd, args] = cmds[how];
+        info(c.dim(`$ ${cmd} ${args.join(" ")}`));
+        const r = spawnSync(cmd, args, { stdio: "inherit" });
+        if (r.status === 0)
+            ok(tr(`Đã nâng lên ${latest ?? channel}.`, `Updated to ${latest ?? channel}.`));
+        else
+            throw new CliError(tr("Nâng cấp không thành công.", "Update failed."), Exit.general);
+    });
+    program.command("init").description(tr(`tạo ${notesFileName()}: chỉ dẫn riêng cho thư mục này`, `create ${notesFileName()}: instructions for this folder`))
+        .action(() => {
+        const f = join(process.cwd(), notesFileName());
+        if (existsSync(f))
+            throw new CliError(tr(`${notesFileName()} đã có.`, `${notesFileName()} already exists.`), Exit.usage);
+        const p = getProfile(context().profile);
+        writeFileSync(f, tr(`# Chỉ dẫn cho ${b.aiName}\n\n${b.aiName} đọc tệp này kèm mỗi câu hỏi khi bạn chạy \`${b.bin}\` trong thư mục này (tối đa 4 KB).\n\n## Bối cảnh\n- Workspace: ${p?.workspaceName ?? ""}\n- Dự án: …\n\n## Quy ước\n- Tiền tệ: VND, làm tròn nghìn.\n- "Khách VIP" = …\n\n## Đừng\n- …\n`, `# Instructions for ${b.aiName}\n\n${b.aiName} reads this file with every question when you run \`${b.bin}\` in this folder (max 4 KB).\n\n## Context\n- Workspace: ${p?.workspaceName ?? ""}\n- Project: …\n\n## Conventions\n- Currency: VND.\n\n## Don't\n- …\n`));
+        ok(tr(`Đã tạo ${f}`, `Created ${f}`));
+    });
+}