@nextxai/cli 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.1.1
+
+- x64 builds (Intel Mac, Linux, Windows) now target every x64 CPU, including older Intel Macs without AVX2.
+- Browser login exits as soon as the browser returns; `login --device` works with the new device-code sign-in page.
+
+## 0.1.0
+
+First release.
+
+- Chat with the assistant in the terminal (`nextx`), 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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NextX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# NextX CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`nextx` brings NextX AI and the NextX developer platform to your terminal.
+
+- **Chat** with NextX AI on your real workspace data: type `nextx`.
+- **Script it**: `nextx -p "question" --json`, stream with `--output-format stream-json`.
+- **Developer tools**: call the API, AI tools, API keys, webhooks (`nextx webhooks listen --forward-to localhost:3000`), MCP setup for other assistants.
+
+Documentation: https://developers.nextx.vn/docs/cli
+
+## Install
+
+macOS / Linux:
+
+```bash
+curl -fsSL https://developers.nextx.vn/install.sh | sh
+```
+
+Windows (PowerShell):
+
+```powershell
+irm https://developers.nextx.vn/install.ps1 | iex
+```
+
+Homebrew:
+
+```bash
+brew install nextx-organization/tap/nextx
+```
+
+npm (Node 20+):
+
+```bash
+npm install -g @nextxai/cli
+```
+
+## Quick start
+
+```bash
+nextx login          # browser, or --qr over SSH
+nextx                # open the chat
+nextx -p "yesterday's revenue by branch"
+nextx doctor
+```
+
+In CI, use an API key (`NEXTX_API_KEY`) or `nextx login --ci` with GitHub Actions OIDC.
+
+## Security
+
+Tokens are kept in the operating system keychain when available. Writes proposed by the assistant are never applied without your confirmation in an interactive terminal. Report vulnerabilities as described in [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT

package/dist/ai/client.js

@@ -0,0 +1,221 @@
+// Chat with the platform assistant over SSE. Shared by `-p` and the REPL.
+import { randomUUID } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { fetch } from "undici";
+import { get, post, put, patch, del, requestRaw, errorFor, networkError } from "../core/http.js";
+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 });
+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"]);
+const MAX_BYTES = 10 * 1024 * 1024;
+const MAX_TEXT = 20_000;
+export function attachmentKind(path) {
+    const ext = extname(path).toLowerCase();
+    if (TABLE.has(ext))
+        return "table";
+    if (ext in IMAGE)
+        return "image";
+    if (TEXT.has(ext))
+        return "text";
+    return undefined;
+}
+async function putFile(url, body, contentType) {
+    let res;
+    try {
+        res = await fetch(url, { method: "PUT", body, headers: { "Content-Type": contentType } });
+    }
+    catch (e) {
+        throw networkError(e, url);
+    }
+    if (!res.ok)
+        throw new CliError(tr(`Tải tệp lên thất bại (HTTP ${res.status}).`, `Upload failed (HTTP ${res.status}).`), Exit.general);
+}
+export async function attach(path, sessionId) {
+    const kind = attachmentKind(path);
+    const name = basename(path);
+    if (!kind)
+        throw new CliError(tr(`Chưa hỗ trợ loại tệp ${extname(path) || name}. Dùng .xlsx/.csv, ảnh .png/.jpg/.webp, hoặc tệp chữ (.txt .md .json …).`, `Unsupported file type ${extname(path) || name}. Use .xlsx/.csv, .png/.jpg/.webp images, or text files (.txt .md .json …).`), Exit.usage);
+    let size;
+    try {
+        size = statSync(path).size;
+    }
+    catch {
+        throw new CliError(tr(`Không đọc được tệp ${path}.`, `Cannot read ${path}.`), Exit.usage);
+    }
+    if (kind === "text") {
+        const raw = readFileSync(path, "utf8");
+        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 (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);
+    if (kind === "table") {
+        const ct = extname(path).toLowerCase() === ".csv" ? "text/csv" : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        const up = await post(`${BASE}/files/upload-url`, { fileName: name, contentType: ct, fileSizeBytes: size });
+        await putFile(up.uploadUrl, body, ct);
+        const s = await post(`${BASE}/files/extract`, { storageKey: up.storageKey, fileName: name, sessionId });
+        return { path, name, kind, fileKey: s.fileId, summary: `${s.rowCount.toLocaleString("vi-VN")} × ${s.columnCount}` };
+    }
+    const ct = IMAGE[extname(path).toLowerCase()];
+    const up = await post("/operator/nextx-ai/attachments/upload-url", { fileName: name, contentType: ct, fileSizeBytes: size });
+    await putFile(up.uploadUrl, body, ct);
+    return { path, name, kind, imageKey: up.storageKey, summary: `${Math.round(size / 1024)} KB` };
+}
+/** Text attachments and NEXTX.md are sent inline, clearly delimited, after the user's question. */
+export function composeText(question, attachments, projectNotes) {
+    const parts = [question];
+    for (const a of attachments.filter((x) => x.kind === "text"))
+        parts.push(`\n\n--- ${tr("Tệp", "File")} ${a.name} ---\n${a.text}\n--- ${tr("Hết tệp", "End of file")} ---`);
+    if (projectNotes)
+        parts.push(`\n\n--- ${tr(`Chỉ dẫn của dự án (${brand().bin.toUpperCase()}.md)`, `Project instructions (${brand().bin.toUpperCase()}.md)`)} ---\n${projectNotes}\n---`);
+    return parts.join("");
+}
+/**
+ * Sends one question and streams the answer. If the connection drops, the same Idempotency-Key is resent,
+ * so the server replays the stored answer instead of answering (and charging) twice.
+ */
+export async function ask(input) {
+    const key = randomUUID();
+    const body = {
+        sessionId: input.sessionId,
+        text: input.text,
+        imageKeys: input.attachments?.filter((a) => a.imageKey).map((a) => a.imageKey) ?? undefined,
+        fileKeys: input.attachments?.filter((a) => a.fileKey).map((a) => a.fileKey) ?? undefined,
+        agentCode: input.agent,
+        clientPlatform: "cli",
+    };
+    let lastErr;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        if (attempt > 0) {
+            input.onRetry?.(attempt);
+            await new Promise((r) => setTimeout(r, 1000 * attempt));
+        }
+        const outcome = { text: "", notices: [], activities: [], ended: "error" };
+        try {
+            const res = await requestRaw("POST", `${BASE}/ask/stream`, { body, idempotencyKey: key, signal: input.signal });
+            if (!res.ok) {
+                const data = await res.json().catch(() => undefined);
+                throw errorFor(res.status, data, res);
+            }
+            if (!res.body)
+                throw new CliError(tr("Máy chủ trả luồng rỗng.", "Empty stream from server."), Exit.general);
+            for await (const chunk of sse(res.body)) {
+                input.onChunk(chunk);
+                switch (chunk.type) {
+                    case "token":
+                        outcome.text += chunk.text ?? "";
+                        break;
+                    case "activity":
+                        if (chunk.activity)
+                            outcome.activities.push(chunk.activity);
+                        outcome.runId ??= chunk.runId ?? undefined;
+                        break;
+                    case "agent":
+                        outcome.agent = chunk.agent ?? undefined;
+                        break;
+                    case "notice":
+                        outcome.notices.push({ code: chunk.code ?? "", message: chunk.message ?? "" });
+                        break;
+                    case "done":
+                    case "error":
+                    case "escalate":
+                    case "delivered_to_agent":
+                        outcome.ended = chunk.type;
+                        outcome.done = chunk;
+                        outcome.runId = chunk.runId ?? outcome.runId;
+                        outcome.proposedAction = chunk.proposedAction ?? undefined;
+                        if (chunk.type === "error" && chunk.text && !outcome.text)
+                            outcome.text = chunk.text;
+                        break;
+                }
+            }
+            if (!outcome.done)
+                throw new CliError(tr("Mất kết nối giữa chừng.", "Connection lost mid-answer."), Exit.network);
+            return outcome;
+        }
+        catch (e) {
+            lastErr = e;
+            const ce = e;
+            // Only transport failures are retried; 4xx/5xx with a body are final.
+            if (input.signal?.aborted || (ce instanceof CliError && ce.exitCode !== Exit.network))
+                throw e;
+        }
+    }
+    throw lastErr;
+}
+async function* sse(stream) {
+    const decoder = new TextDecoder();
+    let buf = "";
+    for await (const part of stream) {
+        buf += decoder.decode(part, { stream: true });
+        let idx;
+        while ((idx = buf.indexOf("\n\n")) >= 0) {
+            const frame = buf.slice(0, idx);
+            buf = buf.slice(idx + 2);
+            const data = frame
+                .split("\n")
+                .filter((l) => l.startsWith("data:"))
+                .map((l) => l.slice(5).trimStart())
+                .join("\n");
+            if (!data)
+                continue;
+            try {
+                yield JSON.parse(data);
+            }
+            catch {
+                // keep-alive or partial garbage
+            }
+        }
+    }
+}
+const FINANCE = /payment|invoice|einvoice|finance|refund|payout|wallet|billing|thanh.?toan|hoa.?don|tien/i;
+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 (FINANCE.test(a.kind))
+        return "finance";
+    if (LARGE.test(a.kind))
+        return "large";
+    if ((a.recipientCount ?? 0) > 20)
+        return "large";
+    try {
+        const p = JSON.parse(a.payloadJson);
+        const n = Object.values(p).find((v) => Array.isArray(v) && v.length > 20);
+        if (n)
+            return "large";
+    }
+    catch {
+        // opaque payload: judged by kind only
+    }
+    return "normal";
+}
+/** Number the user types to confirm a large write (records/recipients), or the action label. */
+export function confirmWord(a) {
+    if (a.recipientCount)
+        return String(a.recipientCount);
+    try {
+        const p = JSON.parse(a.payloadJson);
+        const arr = Object.values(p).find((v) => Array.isArray(v));
+        if (arr && arr.length > 1)
+            return String(arr.length);
+    }
+    catch {
+        // ignore
+    }
+    return tr("dong-y", "confirm");
+}

package/dist/auth/ci.js

@@ -0,0 +1,64 @@
+// Secretless CI login: exchange the CI provider's OIDC token (GitHub Actions, GitLab CI) for a short-lived
+// platform token (RFC 8693). The workspace admin declares which repository/branch may act as whom.
+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 { errorFor, networkError, userAgent } from "../core/http.js";
+import { sessionFrom } from "./session.js";
+import { writeSession } from "./credentials.js";
+import { fetchMe } from "./login.js";
+import { updateProfile } from "../core/config.js";
+export function inCi() {
+    return Boolean(process.env.ACTIONS_ID_TOKEN_REQUEST_URL || process.env.GITLAB_CI || envVar("ID_TOKEN"));
+}
+/** Gets the provider's OIDC token with our authorization server as audience. */
+async function providerToken(audience) {
+    const own = envVar("ID_TOKEN");
+    if (own)
+        return { token: own, provider: process.env.GITLAB_CI ? "gitlab" : "custom" };
+    const url = process.env.ACTIONS_ID_TOKEN_REQUEST_URL;
+    const bearer = process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+    if (url && bearer) {
+        const u = new URL(url);
+        u.searchParams.set("audience", audience);
+        const res = await fetch(u, { headers: { Authorization: `Bearer ${bearer}`, Accept: "application/json" } });
+        if (!res.ok)
+            throw new CliError(tr("Không lấy được token OIDC của GitHub Actions. Thêm `permissions: id-token: write` vào workflow.", "Could not get the GitHub Actions OIDC token. Add `permissions: id-token: write` to the workflow."), Exit.auth);
+        return { token: (await res.json()).value, provider: "github" };
+    }
+    throw new CliError(tr(`Không thấy token OIDC. GitHub: cần \`permissions: id-token: write\`. GitLab: khai \`id_tokens: ${brand().envPrefix}_ID_TOKEN: { aud: ${audience} }\`.`, `No OIDC token found. GitHub: needs \`permissions: id-token: write\`. GitLab: declare \`id_tokens: ${brand().envPrefix}_ID_TOKEN: { aud: ${audience} }\`.`), Exit.auth);
+}
+export async function loginCi(opts) {
+    const ep = context().endpoints;
+    const { token, provider } = await providerToken(ep.auth);
+    const body = {
+        grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+        client_id: brand().clientId,
+        subject_token: token,
+        subject_token_type: "urn:ietf:params:oauth:token-type:jwt",
+        audience: ep.api,
+    };
+    if (opts.workspace)
+        body.workspace = opts.workspace;
+    const url = `${ep.auth}/token`;
+    let res;
+    try {
+        res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded", "User-Agent": userAgent() }, body: new URLSearchParams(body).toString() });
+    }
+    catch (e) {
+        throw networkError(e, url);
+    }
+    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 errorFor(res.status, json, res);
+    }
+    const session = sessionFrom({ ...json, refresh_token: "ci" }, "ci");
+    writeSession(context().profile, session);
+    const me = await fetchMe(session.accessToken);
+    updateProfile(context().profile, { env: context().env, workspaceId: me.workspace?.id, workspaceCode: me.workspace?.code, workspaceName: me.workspace?.name, userEmail: me.email, userName: me.fullName });
+    return { session, userName: me.fullName, userEmail: me.email, workspaceName: me.workspace?.name };
+}

package/dist/auth/credentials.js

@@ -0,0 +1,192 @@
+// Token storage: the OS keychain when available (macOS Keychain, Windows Credential Manager, libsecret),
+// otherwise a 0600 JSON file. Model API keys (--model) are stored the same way under "model:<provider>".
+import { existsSync, readFileSync, writeFileSync, renameSync, chmodSync } from "node:fs";
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { brand } from "../core/brand.js";
+import { credentialsFile } from "../core/paths.js";
+import { t } from "../core/i18n.js";
+import { warn } from "../core/output.js";
+/**
+ * Standalone builds cannot ship the per-platform keychain addon. They talk to the OS tools instead, never
+ * putting the secret on a command line: macOS `security -i` reads commands from stdin (value base64-encoded),
+ * Linux `secret-tool store` reads the secret from stdin.
+ */
+function cliKeyring() {
+    // A keychain item written by another program makes macOS ask the user; never block a script on that dialog.
+    const timeout = process.stdin.isTTY ? 30_000 : 3_000;
+    const has = (cmd, args) => {
+        const r = spawnSync(cmd, args, { stdio: "ignore" });
+        return !r.error && r.status !== null;
+    };
+    if (process.platform === "darwin" && has("/usr/bin/security", ["help"])) {
+        class MacEntry {
+            s;
+            a;
+            constructor(s, a) {
+                this.s = s;
+                this.a = a;
+            }
+            getPassword() {
+                const r = spawnSync("/usr/bin/security", ["find-generic-password", "-s", this.s, "-a", this.a, "-w"], { encoding: "utf8", timeout });
+                if (r.status !== 0)
+                    return null;
+                const v = r.stdout.trim();
+                return v.startsWith("b64:") ? Buffer.from(v.slice(4), "base64").toString("utf8") : v;
+            }
+            setPassword(v) {
+                const enc = "b64:" + Buffer.from(v, "utf8").toString("base64");
+                const r = spawnSync("/usr/bin/security", ["-i"], { input: `add-generic-password -U -s ${this.s} -a ${this.a} -w ${enc}\n`, encoding: "utf8", timeout });
+                if (r.status !== 0)
+                    throw new Error(r.stderr || "security failed");
+            }
+            deletePassword() {
+                return spawnSync("/usr/bin/security", ["delete-generic-password", "-s", this.s, "-a", this.a], { stdio: "ignore" }).status === 0;
+            }
+        }
+        return { Entry: MacEntry };
+    }
+    if (process.platform === "linux" && (process.env.DBUS_SESSION_BUS_ADDRESS || process.env.DISPLAY) && has("secret-tool", ["--version"])) {
+        class LinuxEntry {
+            s;
+            a;
+            constructor(s, a) {
+                this.s = s;
+                this.a = a;
+            }
+            getPassword() {
+                const r = spawnSync("secret-tool", ["lookup", "service", this.s, "account", this.a], { encoding: "utf8", timeout });
+                return r.status === 0 && r.stdout ? r.stdout : null;
+            }
+            setPassword(v) {
+                const r = spawnSync("secret-tool", ["store", "--label", `${this.s} ${this.a}`, "service", this.s, "account", this.a], { input: v, encoding: "utf8", timeout });
+                if (r.status !== 0)
+                    throw new Error(r.stderr || "secret-tool failed");
+            }
+            deletePassword() {
+                return spawnSync("secret-tool", ["clear", "service", this.s, "account", this.a], { stdio: "ignore" }).status === 0;
+            }
+        }
+        return { Entry: LinuxEntry };
+    }
+    return null;
+}
+let keyring;
+let warned = false;
+function loadKeyring() {
+    if (keyring !== undefined)
+        return keyring;
+    if (process.env[`${brand().envPrefix}_NO_KEYCHAIN`] === "1")
+        return (keyring = null);
+    try {
+        const require = createRequire(import.meta.url);
+        const mod = require("@napi-rs/keyring");
+        // Probe once: headless Linux without a secret service throws here.
+        new mod.Entry(service(), "__probe__").getPassword();
+        keyring = mod;
+    }
+    catch {
+        try {
+            keyring = cliKeyring();
+            osTool = keyring !== null;
+        }
+        catch {
+            keyring = null;
+        }
+    }
+    return keyring;
+}
+/**
+ * Each backend owns its own keychain items. Sharing one item between the addon (process "node") and the OS tool
+ * (`security`) makes macOS move the item's access list to whoever wrote last, and every read by the other one
+ * then pops a password dialog (28/10/2026: four dialogs stacked on the user's screen).
+ */
+let osTool = false;
+const service = () => `${brand().bin}-cli${osTool ? "-os" : ""}`;
+function readFileStore() {
+    const f = credentialsFile();
+    if (!existsSync(f))
+        return {};
+    try {
+        return JSON.parse(readFileSync(f, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeFileStore(data) {
+    const f = credentialsFile();
+    const tmp = `${f}.tmp`;
+    writeFileSync(tmp, JSON.stringify(data, null, 1), { mode: 0o600 });
+    renameSync(tmp, f);
+    try {
+        chmodSync(f, 0o600);
+    }
+    catch {
+        // Windows ignores POSIX modes; the file lives under the user's profile.
+    }
+    if (!warned && process.env[`${brand().envPrefix}_NO_KEYCHAIN`] !== "1") {
+        warned = true;
+        warn(t("keychain.fallback", { file: f }));
+    }
+}
+export function storageKind() {
+    return loadKeyring() ? "keychain" : "file";
+}
+export function readSecret(account) {
+    const k = loadKeyring();
+    if (k) {
+        try {
+            return new k.Entry(service(), account).getPassword() ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return readFileStore()[account];
+}
+export function writeSecret(account, value) {
+    const k = loadKeyring();
+    if (k) {
+        new k.Entry(service(), account).setPassword(value);
+        return;
+    }
+    const s = readFileStore();
+    s[account] = value;
+    writeFileStore(s);
+}
+export function deleteSecret(account) {
+    const k = loadKeyring();
+    if (k) {
+        try {
+            new k.Entry(service(), account).deletePassword();
+        }
+        catch {
+            // already gone
+        }
+        return;
+    }
+    const s = readFileStore();
+    if (account in s) {
+        delete s[account];
+        writeFileStore(s);
+    }
+}
+export function readSession(profile) {
+    const raw = readSecret(`session:${profile}`);
+    if (!raw)
+        return undefined;
+    try {
+        const s = JSON.parse(raw);
+        return s.kind === "session" && s.accessToken && s.refreshToken ? s : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeSession(profile, s) {
+    writeSecret(`session:${profile}`, JSON.stringify(s));
+}
+export function deleteSession(profile) {
+    deleteSecret(`session:${profile}`);
+}

package/dist/auth/device.js

@@ -0,0 +1,76 @@
+// OAuth 2.0 Device Authorization Grant (RFC 8628) for machines with neither a browser nor the mobile app.
+import { setTimeout as sleep } from "node:timers/promises";
+import { fetch } from "undici";
+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";
+import { c, info } from "../core/output.js";
+import { errorFor, networkError, userAgent } from "../core/http.js";
+import { sessionFrom, switchWorkspace, listWorkspaces, findWorkspace } from "./session.js";
+import { writeSession } from "./credentials.js";
+import { fetchMe } from "./login.js";
+import { updateProfile } from "../core/config.js";
+async function form(url, body) {
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded", "User-Agent": userAgent() },
+            body: new URLSearchParams(body).toString(),
+        });
+        return { res, json: (await res.json().catch(() => ({}))) };
+    }
+    catch (e) {
+        throw networkError(e, url);
+    }
+}
+export async function loginDevice(opts) {
+    const ep = context().endpoints;
+    const start = await form(`${ep.auth}/device_authorization`, { client_id: brand().clientId, scope: "openid profile email" });
+    if (start.res.status === 404)
+        throw new CliError(tr("Máy chủ chưa hỗ trợ đăng nhập bằng mã thiết bị.", "The server does not support device login yet."), Exit.general, `${brand().bin} login --qr`);
+    if (!start.res.ok)
+        throw errorFor(start.res.status, start.json, start.res);
+    const d = start.json;
+    info(tr("  Trên máy bất kỳ, mở", "  On any device, open") + ` ${c.yellow(d.verification_uri)} ` + tr("và nhập mã:", "and enter the code:"));
+    info();
+    info(`        ${c.bold(d.user_code)}          ${c.dim(tr(`hết hạn sau ${Math.round(d.expires_in / 60)} phút`, `expires in ${Math.round(d.expires_in / 60)} minutes`))}`);
+    info();
+    if (d.verification_uri_complete)
+        info(c.dim(`  ${d.verification_uri_complete}`));
+    let interval = Math.max(d.interval ?? 5, 1);
+    const deadline = Date.now() + d.expires_in * 1000;
+    while (Date.now() < deadline) {
+        await sleep(interval * 1000);
+        const r = await form(`${ep.auth}/token`, {
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+            device_code: d.device_code,
+            client_id: brand().clientId,
+        });
+        if (r.res.ok) {
+            const session = sessionFrom(r.json, "device");
+            writeSession(context().profile, session);
+            const me = await fetchMe(session.accessToken);
+            updateProfile(context().profile, { env: context().env, workspaceId: me.workspace?.id, workspaceCode: me.workspace?.code, workspaceName: me.workspace?.name, userEmail: me.email, userName: me.fullName });
+            if (opts.workspace) {
+                const target = findWorkspace(await listWorkspaces(), opts.workspace);
+                if (target && target.id !== me.workspace?.id)
+                    await switchWorkspace(target);
+            }
+            return { session, userName: me.fullName, userEmail: me.email, workspaceName: me.workspace?.name };
+        }
+        const err = String(r.json.error ?? "");
+        if (err === "authorization_pending")
+            continue;
+        if (err === "slow_down") {
+            interval += 5;
+            continue;
+        }
+        if (err === "access_denied")
+            throw new CliError(tr("Đăng nhập bị từ chối.", "Login was denied."), Exit.auth);
+        if (err === "expired_token")
+            break;
+        throw errorFor(r.res.status, r.json, r.res);
+    }
+    throw new CliError(tr("Mã đã hết hạn. Chạy lại lệnh đăng nhập.", "The code expired. Run login again."), Exit.auth);
+}