@nextxai/cli 0.1.0 → 0.2.0

package/dist/ai/nextfarm.js

@@ -0,0 +1,387 @@
+// NextFarm assistant contract. Same exported shapes as client.ts, different server:
+//   POST /ai/agent-runs → GET /ai/agent-runs/{id}/events (SSE, resumable with Last-Event-ID)
+//   POST /ai/action-proposals/{id}/decision|undo (Idempotency-Key required)
+// REST bodies are snake_case both ways; SSE event payloads are camelCase.
+import { randomUUID } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { FormData } from "undici";
+import { get, post, patch, del, requestRaw, errorFor } from "../core/http.js";
+import { CliError, Exit } from "../core/errors.js";
+import { currentLang, tr } from "../core/i18n.js";
+/** First present key, snake or camel. */
+function pick(o, ...keys) {
+    if (!o || typeof o !== "object")
+        return undefined;
+    for (const k of keys)
+        if (o[k] !== undefined && o[k] !== null)
+            return o[k];
+    return undefined;
+}
+// ── Conversations ───────────────────────────────────────────────────────────────────────────────────
+/** A new conversation is created by the first run; "" means "start one". */
+export const openConversation = async (_forceNew) => ({ sessionId: "", greeting: "", suggestedQuestions: [], status: "active" });
+export async function listConversations(limit = 30) {
+    const r = await get("/ai/conversations", { query: { page: 1, page_size: Math.min(limit, 50) } });
+    return (pick(r, "items") ?? []).map((x) => ({
+        sessionId: String(pick(x, "conversation_id", "conversationId")),
+        title: pick(x, "title") ?? null,
+        lastPreview: pick(x, "title") ?? null,
+        isPinned: Boolean(pick(x, "pinned")),
+        status: pick(x, "status"),
+        updatedAt: String(pick(x, "last_message_at", "lastMessageAt", "updated_at", "updatedAt") ?? ""),
+    }));
+}
+export const renameConversation = (id, title) => patch(`/ai/conversations/${id}`, { title: title ?? "" });
+export const pinConversation = (id, pinned) => patch(`/ai/conversations/${id}`, { pinned });
+export const deleteConversation = (id) => del(`/ai/conversations/${id}`);
+export async function history(sessionId) {
+    if (!sessionId)
+        return [];
+    const r = await get(`/ai/conversations/${sessionId}`);
+    return (pick(r, "messages") ?? []).map((m) => ({
+        id: String(pick(m, "message_id", "messageId")),
+        role: pick(m, "role") === "user" ? "User" : "Assistant",
+        text: pick(m, "text") ?? "",
+        createdAt: String(pick(m, "created_at", "createdAt") ?? ""),
+    }));
+}
+/** NextFarm rates a whole run, so `messageId` here is the run id (see `done.messageId` below). */
+export const feedback = (runId, helpful) => post(`/ai/agent-runs/${runId}/feedback`, { rating: helpful ? "up" : "down" });
+export const escalate = async (_sessionId, _topic) => {
+    throw new CliError(tr("NextFarm chưa có chuyển cho nhân viên hỗ trợ từ terminal.", "Handing over to a support agent is not available for NextFarm yet."), Exit.general);
+};
+export async function usage() {
+    const q = await get("/ai/assistant/quota");
+    const limit = Number(pick(q, "limit") ?? 0);
+    return {
+        planName: tr("Tuần này", "This week"),
+        used: Number(pick(q, "used") ?? 0),
+        limit,
+        remaining: Number(pick(q, "remaining") ?? 0),
+        resetsAt: nextMondayVietnam(),
+        enforced: limit > 0,
+    };
+}
+/** The weekly quota resets at 00:00 Monday, Vietnam time (UTC+7). */
+export function nextMondayVietnam(now = new Date()) {
+    const vn = new Date(now.getTime() + 7 * 3600_000);
+    const days = ((8 - vn.getUTCDay()) % 7) || 7;
+    const d = new Date(Date.UTC(vn.getUTCFullYear(), vn.getUTCMonth(), vn.getUTCDate() + days));
+    return `${d.toISOString().slice(0, 10)}T00:00:00+07:00`;
+}
+// ── Attachments ─────────────────────────────────────────────────────────────────────────────────────
+const IMAGE = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
+const DOCUMENT = {
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".csv": "text/csv",
+    ".pdf": "application/pdf",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+};
+const MAX_BYTES = 10 * 1024 * 1024;
+/** Images go to /ai/attachments, documents to /ai/files; both return an id the run references. */
+export async function attachBinary(path, kind) {
+    const name = basename(path);
+    const ext = extname(path).toLowerCase();
+    const size = statSync(path).size;
+    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 type = kind === "image" ? IMAGE[ext] : DOCUMENT[ext];
+    if (!type)
+        throw new CliError(tr(`Chưa hỗ trợ ${ext}.`, `Unsupported ${ext}.`), Exit.usage);
+    const form = new FormData();
+    form.append("file", new Blob([readFileSync(path)], { type }), name);
+    const r = await post(kind === "image" ? "/ai/attachments" : "/ai/files", form);
+    const id = String(pick(r, "attachment_id", "attachmentId", "id"));
+    return kind === "image"
+        ? { path, name, kind, imageKey: id, summary: `${Math.round(size / 1024)} KB` }
+        : { path, name, kind, fileKey: id, summary: `${Math.round(size / 1024)} KB` };
+}
+export const isDocument = (path) => extname(path).toLowerCase() in DOCUMENT;
+/** Last proposal written from this process — `/undo` without an id targets it. */
+export let lastWritten;
+export async function ask(input) {
+    const attachmentIds = [...new Set(input.attachments?.flatMap((a) => [a.imageKey, a.fileKey]).filter(Boolean) ?? [])];
+    const created = await post("/ai/agent-runs", {
+        message: input.text,
+        route_key: "assistant.orchestrate",
+        app_id: "farm",
+        locale: currentLang(),
+        conversation_id: input.sessionId || null,
+        client_request_id: randomUUID(),
+        attachment_ids: attachmentIds,
+    }, { signal: input.signal });
+    const runId = String(pick(created, "run_id", "runId", "id"));
+    const outcome = {
+        text: "", notices: [], activities: [], ended: "error", runId,
+        sessionId: String(pick(created, "conversation_id", "conversationId") ?? input.sessionId ?? ""),
+    };
+    const proposals = [];
+    // The run lives on the server; a dropped stream reconnects from the last event instead of asking again.
+    let lastEventId;
+    for (let attempt = 0;; attempt++) {
+        if (attempt > 0) {
+            if (attempt > 5)
+                throw new CliError(tr("Mất kết nối giữa chừng.", "Connection lost mid-answer."), Exit.network);
+            input.onRetry?.(attempt);
+            await new Promise((r) => setTimeout(r, 1000 * attempt));
+        }
+        try {
+            const res = await requestRaw("GET", `/ai/agent-runs/${runId}/events`, {
+                signal: input.signal,
+                headers: { Accept: "text/event-stream", ...(lastEventId ? { "Last-Event-ID": lastEventId } : {}) },
+            });
+            if (!res.ok)
+                throw errorFor(res.status, await res.json().catch(() => undefined), 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 ev of events(res.body)) {
+                lastEventId = ev.id ?? lastEventId;
+                const chunk = toChunk(ev, outcome, proposals);
+                if (chunk)
+                    input.onChunk(chunk);
+                if (outcome.done) {
+                    outcome.proposedAction = proposals[0];
+                    if (proposals.length > 1)
+                        outcome.notices.push({ code: "proposals", message: tr(`Còn ${proposals.length - 1} đề xuất khác — xem trong app.`, `${proposals.length - 1} more proposals — see the app.`) });
+                    return outcome;
+                }
+            }
+            throw new CliError(tr("Mất kết nối giữa chừng.", "Connection lost mid-answer."), Exit.network);
+        }
+        catch (e) {
+            if (input.signal?.aborted) {
+                await post(`/ai/agent-runs/${runId}/cancel`, {}).catch(() => undefined);
+                throw e;
+            }
+            if (!(e instanceof CliError) || e.exitCode !== Exit.network)
+                throw e;
+        }
+    }
+}
+function toChunk(ev, out, proposals) {
+    const p = ev.payload ?? {};
+    switch (ev.type) {
+        case "progress.updated": {
+            const activity = { kind: "tool", label: String(p.label ?? ""), toolName: p.toolName ?? null };
+            if (p.completed)
+                return undefined;
+            out.activities.push(activity);
+            return { type: "activity", activity, runId: out.runId };
+        }
+        case "assistant.message_delta": {
+            // Leading blank deltas would print empty lines before the answer.
+            const delta = out.text ? String(p.delta ?? "") : String(p.delta ?? "").trimStart();
+            if (!delta)
+                return undefined;
+            out.text += delta;
+            return { type: "token", text: delta };
+        }
+        case "assistant.message_completed": {
+            const text = String(pick(p.message, "text") ?? "");
+            // Some answers arrive whole, without deltas.
+            if (!out.text && text) {
+                out.text = text;
+                return { type: "token", text };
+            }
+            return undefined;
+        }
+        case "action.approval_required":
+            proposals.push(toProposal(String(p.proposalId), String(p.actionType), p.proposal));
+            return undefined;
+        case "ui.action_requested": {
+            // Clarifying question: { action: "ask", label, value: '{"options":[…]}' }. Options become numbered follow-ups (type 1, 2, 3).
+            if (p.action !== "ask" || typeof p.label !== "string")
+                return undefined;
+            let options = [];
+            try {
+                options = (JSON.parse(String(p.value ?? "{}")).options ?? []).filter((x) => typeof x === "string");
+            }
+            catch {
+                // question without options
+            }
+            out.followUps = options;
+            const text = `${out.text ? "\n\n" : ""}${p.label.trim()}${options.map((o, i) => `\n  ${i + 1}. ${o}`).join("")}`;
+            out.text += text;
+            return { type: "token", text };
+        }
+        case "run.completed":
+        case "run.awaiting_user":
+            out.ended = "done";
+            out.done = { type: "done", messageId: out.runId, runId: out.runId, followUps: out.followUps ?? [] };
+            return out.done;
+        case "run.cancelled":
+        case "run.failed": {
+            const message = String(p.errorMessage ?? (ev.type === "run.cancelled" ? tr("Đã dừng.", "Stopped.") : tr("Trợ lý gặp lỗi, thử lại.", "The assistant failed, try again.")));
+            out.ended = "error";
+            out.done = { type: "error", code: String(p.errorCode ?? ev.type), message, text: message, runId: out.runId };
+            if (!out.text)
+                out.text = message;
+            return out.done;
+        }
+        default:
+            return undefined;
+    }
+}
+async function* events(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 {
+                // heartbeat or partial frame
+            }
+        }
+    }
+}
+// ── Proposals ───────────────────────────────────────────────────────────────────────────────────────
+/** Line kinds that move money or touch devices: never confirmed from the terminal (the server enforces it too). */
+const FINANCE_KINDS = new Set(["cash", "settlement", "purchase_slip"]);
+function kindsOf(v, acc = []) {
+    if (Array.isArray(v))
+        for (const x of v)
+            kindsOf(x, acc);
+    else if (v && typeof v === "object")
+        for (const [k, x] of Object.entries(v)) {
+            if (k === "kind" && typeof x === "string")
+                acc.push(x);
+            else
+                kindsOf(x, acc);
+        }
+    return acc;
+}
+function entriesOf(v) {
+    if (!v || typeof v !== "object")
+        return [];
+    if (Array.isArray(v.entries))
+        return v.entries;
+    for (const x of Object.values(v)) {
+        const found = entriesOf(x);
+        if (found.length)
+            return found;
+    }
+    return [];
+}
+export function riskOfNextFarm(actionType, proposal) {
+    if (/^(automation|iot|drone)\./.test(actionType))
+        return "device";
+    const kinds = kindsOf(proposal);
+    if (kinds.some((k) => k.startsWith("iot_")))
+        return "device";
+    if (kinds.some((k) => FINANCE_KINDS.has(k)))
+        return "finance";
+    if (entriesOf(proposal).length > 20 || kinds.some((k) => /close|return|delete|remove/.test(k)))
+        return "large";
+    return "normal";
+}
+function toProposal(proposalId, actionType, proposal) {
+    const entries = entriesOf(proposal);
+    const summary = pick(proposal, "summary", "title") ?? "";
+    const lines = entries.length
+        ? entries.map((e) => `+ ${pick(e, "label") ?? pick(pick(e, "display"), "title") ?? pick(e, "kind") ?? ""}`)
+        : summary ? [] : [JSON.stringify(proposal).slice(0, 300)];
+    return {
+        kind: actionType,
+        label: summary || (entries.length ? tr(`Ghi ${entries.length} mục`, `Write ${entries.length} entries`) : actionType),
+        confirmPrompt: lines.join("\n"),
+        payloadJson: JSON.stringify(proposal ?? {}),
+        writes: true,
+        nonce: proposalId,
+        recipientCount: entries.length > 1 ? entries.length : null,
+        risk: riskOfNextFarm(actionType, proposal),
+    };
+}
+const EXECUTED = new Set(["succeeded", "partial"]);
+export async function confirmAction(_sessionId, a) {
+    const r = await post(`/ai/action-proposals/${a.nonce}/decision`, { approved: true }, { idempotencyKey: true });
+    const execution = String(pick(r, "execution") ?? "");
+    const lines = pick(r, "lines") ?? [];
+    const ok = lines.filter((l) => pick(l, "status") === "succeeded").length;
+    const failed = lines.filter((l) => ["failed", "outcome_unknown"].includes(String(pick(l, "status")))).length;
+    const success = EXECUTED.has(execution);
+    const codes = [...new Set(lines.filter((l) => pick(l, "code")).map((l) => String(pick(l, "code"))))];
+    if (success)
+        lastWritten = { proposalId: a.nonce, label: a.label };
+    const message = execution === "deterministic_command_required"
+        ? tr("Đã ghi nhận đồng ý. Việc này hoàn tất trong app NextFarm.", "Approval recorded. Finish this in the NextFarm app.")
+        : success
+            ? tr(`Đã ghi ${ok || lines.length} mục${failed ? `, ${failed} mục lỗi — xem trong app` : ""}.`, `Wrote ${ok || lines.length} entries${failed ? `, ${failed} failed — check the app` : ""}.`)
+            : tr(`Chưa ghi được (${[execution || "không rõ", ...codes].join(" · ")}).`, `Not written (${[execution || "unknown", ...codes].join(" · ")}).`);
+    return { success, message, messageId: a.nonce, kind: a.kind, writes: true };
+}
+export async function rejectAction(proposalId) {
+    await post(`/ai/action-proposals/${proposalId}/decision`, { approved: false }, { idempotencyKey: true });
+}
+/** What `/undo` would revert: the given proposal, or the last one written from this process. */
+export function undoTarget(proposalId) {
+    const target = proposalId ? { proposalId, label: proposalId.slice(0, 8) } : lastWritten;
+    if (!target)
+        throw new CliError(tr("Chưa có lần ghi nào trong phiên này để hoàn tác.", "Nothing written in this session to undo."), Exit.notFound);
+    return target;
+}
+export async function undo(target) {
+    const r = await post(`/ai/action-proposals/${target.proposalId}/undo`, {}, { idempotencyKey: true });
+    const undone = (pick(r, "lines") ?? []).filter((l) => pick(l, "undone")).length;
+    return tr(`Đã hoàn tác${undone ? ` ${undone} mục` : ""}.`, `Undone${undone ? ` ${undone} entries` : ""}.`);
+}
+// ── Run trace, memory, schedules, brief ─────────────────────────────────────────────────────────────
+export async function runTrace(runId) {
+    const r = await get(`/ai/agent-runs/${runId}`);
+    const status = String(pick(r, "status") ?? "");
+    const steps = (pick(r, "activities", "progress") ?? []).map((s, i) => `  ${i + 1}. ${pick(s, "label") ?? ""}${pick(s, "tool_name", "toolName") ? ` · ${pick(s, "tool_name", "toolName")}` : ""}`);
+    return [`  ${tr("Lượt", "Run")} ${runId.slice(0, 8)} · ${status}`, ...(steps.length ? steps : [tr("  (không có bước công cụ)", "  (no tool steps)")])];
+}
+export async function memories() {
+    const r = await get("/ai/memories");
+    return {
+        canDelete: Boolean(pick(r, "can_delete", "canDelete")),
+        items: (pick(r, "items") ?? []).map((m) => ({
+            id: String(pick(m, "id")),
+            display: `${pick(m, "key") ?? ""}: ${pick(m, "value") ?? ""}`,
+            kind: String(pick(m, "kind") ?? ""),
+            uses: Number(pick(m, "use_count", "useCount") ?? 0),
+        })),
+    };
+}
+export const forgetMemory = (id) => del(`/ai/memories/${id}`);
+export async function schedules() {
+    const r = await get("/ai/scheduled-prompts");
+    const list = Array.isArray(r) ? r : (pick(r, "items") ?? []);
+    return list.map((s) => ({
+        id: String(pick(s, "id")),
+        title: String(pick(s, "title", "prompt") ?? ""),
+        when: `${(pick(s, "days_of_week", "daysOfWeek") ?? []).length ? `${tr("thứ", "days")} ${(pick(s, "days_of_week", "daysOfWeek") ?? []).join(",")}` : tr("hằng ngày", "daily")} ${pick(s, "time_of_day", "timeOfDay") ?? ""}`,
+        nextRunAt: String(pick(s, "next_run_at", "nextRunAt") ?? ""),
+        enabled: pick(s, "enabled") !== false,
+    }));
+}
+/** daily → every day; weekly N → ISO weekday N (1 = Monday). Running in the background needs the app's one-time consent. */
+export async function createSchedule(question, frequency, timeOfDay, day) {
+    const r = await post("/ai/scheduled-prompts", {
+        title: question.slice(0, 60), question, time_of_day: timeOfDay, days_of_week: frequency === "weekly" ? [day ?? 1] : [], channels: ["app"], enabled: true,
+    });
+    return (await schedules()).find((x) => x.id === String(pick(r, "id"))) ?? { id: String(pick(r, "id")), title: question, when: timeOfDay, nextRunAt: "", enabled: true };
+}
+export const runSchedule = (id) => post(`/ai/scheduled-prompts/${id}/run`, {});
+export const deleteSchedule = (id) => del(`/ai/scheduled-prompts/${id}`);
+/** Latest morning brief, or undefined when none was sent yet. */
+export async function latestBrief() {
+    const r = await get("/ai/briefs/latest");
+    if (!r)
+        return undefined;
+    return {
+        title: String(pick(r, "title", "subject") ?? tr("Bản tin sáng", "Morning brief")),
+        text: String(pick(r, "text", "body", "content", "summary") ?? ""),
+        createdAt: String(pick(r, "created_at", "createdAt") ?? ""),
+    };
+}

package/dist/auth/ci.js

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

package/dist/auth/mcp-oauth.js

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

package/dist/auth/session.js

@@ -2,6 +2,7 @@
 // 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";
@@ -79,6 +80,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". */
+export function refreshBody(url, refreshToken) {
+    const body = { refreshToken };
+    return JSON.stringify(snakeOnWire(url) ? snakeKeys(body) : body);
+}
 export async function refreshSession(staleAccess) {
     const profile = context().profile;
     return withFileLock(lockFile(profile), async () => {
@@ -99,7 +105,7 @@ export async function refreshSession(staleAccess) {
             res = await fetch(url, {
                 method: "POST",
                 headers: { "Content-Type": "application/json", "X-Client-Type": "cli", "User-Agent": `${brand().bin}-cli` },
-                body: JSON.stringify({ refreshToken: s.refreshToken }),
+                body: refreshBody(url, s.refreshToken),
             });
         }
         catch (e) {

package/dist/commands/ai-nextfarm.js

@@ -0,0 +1,109 @@
+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 } from "../core/http.js";
+import { hasTty, confirm } from "../core/prompt.js";
+import { requirePerson } from "../auth/session.js";
+import * as nf from "../ai/nextfarm.js";
+import { feedback, usage } from "../ai/client.js";
+import { markdown } from "../repl/markdown.js";
+import { runRoot } from "./ai.js";
+const when = (s) => s.slice(0, 16).replace("T", " ");
+export function registerAiNextFarm(ai, program) {
+    ai.command("why [runId]")
+        .description(tr("vì sao trợ lý trả lời vậy: các bước, công cụ đã gọi", "why the assistant answered that way: steps and tools"))
+        .action(async (runId) => {
+        await requirePerson();
+        const id = runId ?? (await get("/ai/agent-runs", { query: { page_size: 1 } })).items?.[0];
+        const rid = typeof id === "string" ? id : id?.run_id ?? id?.id;
+        if (!rid)
+            throw new CliError(tr("Chưa có lượt chạy nào.", "No runs yet."), Exit.notFound);
+        const lines = await nf.runTrace(rid);
+        emit({ runId: rid, steps: lines }, () => info(lines.join("\n")));
+    });
+    ai.command("apply <proposalId>").description(tr("xác nhận một đề xuất ghi (ghi thật)", "approve a proposed write (real write)"))
+        .action(async (proposalId) => {
+        await requirePerson();
+        if (hasTty() && !(await confirm(tr(`Ghi đề xuất ${proposalId.slice(0, 8)}?`, `Write proposal ${proposalId.slice(0, 8)}?`))))
+            return;
+        // Device, automation and money lines are refused by the server for the CLI (403 proposal.requires_app).
+        const r = await nf.confirmAction("", { kind: "", label: proposalId.slice(0, 8), confirmPrompt: "", payloadJson: "{}", writes: true, nonce: proposalId });
+        emit(r, () => (r.success ? ok(r.message) : info(c.yellow(`⚠ ${r.message}`))));
+        if (!r.success)
+            process.exitCode = Exit.notConfirmed;
+    });
+    ai.command("reject <proposalId>").description(tr("từ chối một đề xuất ghi", "reject a proposed write"))
+        .action(async (proposalId) => {
+        await nf.rejectAction(proposalId);
+        ok(tr("Đã từ chối.", "Rejected."));
+    });
+    ai.command("undo <proposalId>").description(tr("hoàn tác đề xuất đã ghi (trong 24 giờ)", "undo a written proposal (within 24 hours)"))
+        .action(async (proposalId) => {
+        if (hasTty() && !(await confirm(tr("Hoàn tác?", "Undo?"))))
+            return;
+        ok(await nf.undo(nf.undoTarget(proposalId)));
+    });
+    const mem = ai.command("memory").description(tr("trợ lý đang nhớ gì về trang trại", "what the assistant remembers about the farm"));
+    mem.command("list", { isDefault: true }).action(async () => {
+        const m = await nf.memories();
+        emit(m.items, () => info(m.items.length ? table(["ID", tr("Điều nhớ", "Memory"), tr("Dùng", "Uses")], m.items.map((x) => [x.id.slice(0, 8), x.display, x.uses])) : tr("Trợ lý chưa nhớ gì.", "Nothing remembered yet.")));
+    });
+    mem.command("forget <id>").description(tr("quên một điều (chỉ chủ trại)", "forget one item (farm owner only)")).action(async (id) => {
+        const hit = (await nf.memories()).items.find((x) => x.id.startsWith(id));
+        if (!hit)
+            throw new CliError(tr("Không thấy điều nhớ này.", "Memory not found."), Exit.notFound);
+        await nf.forgetMemory(hit.id);
+        ok(tr("Đã quên.", "Forgotten."));
+    });
+    const sch = ai.command("schedule").description(tr("câu hỏi chạy định kỳ", "recurring questions"));
+    sch.command("list", { isDefault: true }).action(async () => {
+        const list = await nf.schedules();
+        emit(list, () => info(table(["ID", tr("Tên", "Title"), tr("Lịch", "When"), tr("Lần tới", "Next")], list.map((s) => [s.id.slice(0, 8), s.title, s.when, when(s.nextRunAt)]))));
+    });
+    sch.command("add <question>")
+        .requiredOption("--at <HH:mm>", tr("giờ chạy (giờ Việt Nam)", "time (Vietnam time)"))
+        .option("--weekday <1-7>", tr("chỉ một ngày trong tuần (1 = thứ Hai); bỏ trống = hằng ngày", "one weekday only (1 = Monday); omit = daily"))
+        .action(async (question, o) => {
+        const s = await nf.createSchedule(question, o.weekday ? "weekly" : "daily", o.at.padStart(5, "0"), o.weekday ? Number(o.weekday) : undefined);
+        emit(s, () => {
+            ok(tr(`Đã lên lịch · ${s.when}`, `Scheduled · ${s.when}`));
+            info(c.dim(tr(`  Mở mục Trợ lý AI trong app ${brand().mobileApp} một lần để cho phép chạy nền.`, `  Open the AI assistant in the ${brand().mobileApp} app once to allow background runs.`)));
+        });
+    });
+    sch.command("run <id>").action(async (id) => {
+        const hit = (await nf.schedules()).find((s) => s.id.startsWith(id));
+        if (!hit)
+            throw new CliError(tr("Không thấy lịch.", "Schedule not found."), Exit.notFound);
+        await nf.runSchedule(hit.id);
+        ok(tr("Đã chạy.", "Run started."));
+    });
+    sch.command("delete <id>").action(async (id) => {
+        const hit = (await nf.schedules()).find((s) => s.id.startsWith(id));
+        if (!hit)
+            throw new CliError(tr("Không thấy lịch.", "Schedule not found."), Exit.notFound);
+        await nf.deleteSchedule(hit.id);
+        ok(tr("Đã xoá.", "Deleted."));
+    });
+    ai.command("brief").description(tr("bản tin sáng mới nhất", "latest morning brief"))
+        .action(async () => {
+        const b = await nf.latestBrief();
+        emit(b ?? null, () => info(b ? `${c.bold(b.title)} ${c.dim(when(b.createdAt))}\n${markdown(b.text)}` : tr("Chưa có bản tin sáng.", "No morning brief yet.")));
+    });
+    ai.command("pest <photo> [note...]").description(tr("chẩn đoán sâu bệnh từ ảnh", "diagnose pests and diseases from a photo"))
+        .action(async (photo, note) => {
+        const root = program.opts();
+        const q = note.length ? note.join(" ") : tr("Ảnh này cây bị sâu bệnh gì? Mức độ, cách xử lý và lô nào cần kiểm tra thêm.", "What pest or disease is in this photo? Severity, treatment and which plots to check.");
+        await runRoot({ ...root, print: q, file: [photo, ...(root.file ?? [])] }, []);
+    });
+    ai.command("usage").description(tr("câu hỏi AI còn lại tuần này", "AI questions left this week"))
+        .action(async () => {
+        const u = await usage();
+        emit(u, () => info(tr(`Tuần này: đã dùng ${u.used}/${u.limit} câu · còn ${u.remaining} · mở lại 00:00 thứ Hai`, `This week: ${u.used}/${u.limit} used · ${u.remaining} left · resets Monday 00:00`)));
+    });
+    ai.command("feedback <runId> <vote>").description(tr("báo câu trả lời tốt (up) / chưa tốt (down)", "rate an answer: up / down"))
+        .action(async (runId, vote) => {
+        await feedback(runId, vote === "up");
+        ok(tr("Cảm ơn bạn đã góp ý.", "Thanks for the feedback."));
+    });
+}