@bergetai/odoo-cli 0.12.1 → 0.12.2

package/dist/commands/sales.js

@@ -0,0 +1,902 @@
+/**
+ * Sales surface (sale.order, sale.order.line, sale.subscription.plan).
+ *
+ * Custom commands (not the shared list/show engine) because order reads
+ * include order lines + partner details, creates take order lines as JSON,
+ * and the surface includes a portal-PDF download and an invoicing-precedent
+ * report. Helpers (resolveReference, authenticatedClient, table/json output,
+ * dry-run diffing style) mirror crm.ts/mutation.ts.
+ *
+ * Sending quotations is deliberately NOT implemented (see group help text).
+ */
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { resolveConfig } from "../config.js";
+import { conflictError, networkError, notFoundError, usageError, } from "../errors.js";
+import { buildFilterClauses, parseDomain, parseFilterScalar } from "../filter.js";
+import { ModelFields, resolveReference } from "../model.js";
+import { parseDate } from "../mutation.js";
+import { colorEnabled, printJson, verbose as logVerbose } from "../output.js";
+import { authenticatedClient, parseId, } from "../resource.js";
+import { formatKeyValues, formatTable, humanCell } from "../table.js";
+// ---------------------------------------------------------------------------
+// shared constants
+// ---------------------------------------------------------------------------
+const SALE_ORDER = "sale.order";
+const SALE_ORDER_LINE = "sale.order.line";
+const SUBSCRIPTION_PLAN = "sale.subscription.plan";
+const STATE_LABELS = {
+    draft: "Quotation",
+    sent: "Quotation Sent",
+    sale: "Sales Order",
+    cancel: "Cancelled",
+};
+const LIST_FIELDS = [
+    "id",
+    "name",
+    "partner_id",
+    "state",
+    "pricelist_id",
+    "currency_id",
+    "amount_untaxed",
+    "amount_total",
+    "user_id",
+    "validity_date",
+    "plan_id",
+];
+const READ_FIELDS = [
+    "id",
+    "name",
+    "state",
+    "partner_id",
+    "pricelist_id",
+    "currency_id",
+    "payment_term_id",
+    "validity_date",
+    "opportunity_id",
+    "user_id",
+    "note",
+    "plan_id",
+    "is_subscription",
+    "recurring_total",
+    "recurring_monthly",
+    "access_token",
+    "amount_untaxed",
+    "amount_tax",
+    "amount_total",
+    "order_line",
+    "create_date",
+];
+const LINE_FIELDS = [
+    "id",
+    "sequence",
+    "display_type",
+    "name",
+    "product_id",
+    "product_uom_qty",
+    "price_unit",
+    "discount",
+    "tax_id",
+    "price_subtotal",
+    "price_total",
+];
+/** Header fields that `orders update --set` accepts (guardrail, §spec). */
+const UPDATABLE_HEADER_FIELDS = new Set([
+    "plan_id",
+    "pricelist_id",
+    "payment_term_id",
+    "validity_date",
+    "note",
+    "opportunity_id",
+    "user_id",
+]);
+/** read all of stdin as utf8 */
+function readStdin() {
+    return new Promise((resolveP, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (c) => chunks.push(c));
+        process.stdin.on("end", () => resolveP(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", reject);
+    });
+}
+async function readLinesFile(path) {
+    let raw;
+    if (path === "-") {
+        if (process.stdin.isTTY) {
+            throw usageError("--lines - expects a JSON array on stdin, but stdin is a TTY", 'pipe a JSON array on stdin, e.g. echo \'[{"product_id":188,"price_unit":150}]\' | odoo sales orders create ... --lines -');
+        }
+        raw = await readStdin();
+    }
+    else {
+        try {
+            raw = await readFile(path, "utf8");
+        }
+        catch (cause) {
+            throw usageError(`could not read --lines file ${path}: ${cause.code ?? cause.message}`);
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw usageError(`--lines ${path === "-" ? "stdin" : path} is not valid JSON`, "expected a JSON array of order line objects");
+    }
+    if (!Array.isArray(parsed)) {
+        throw usageError("--lines must be a JSON array of order line objects", 'line format: {"display_type":"line_section","name":"..."} or {"product_id":188,"product_uom_qty":1,"price_unit":150,"tax_ids":[37]}');
+    }
+    return parsed;
+}
+/**
+ * Validate one line spec and build the sale.order.line wire dict. For product
+ * lines a missing name defaults to the product's display name and a missing
+ * price_unit to the product's list price (API create has no onchange).
+ */
+async function buildLineValues(client, spec, index) {
+    if (typeof spec !== "object" || spec === null || Array.isArray(spec)) {
+        throw usageError(`line ${index + 1}: expected a JSON object`);
+    }
+    const values = {};
+    if (spec.display_type !== undefined) {
+        if (spec.display_type !== "line_section" && spec.display_type !== "line_note") {
+            throw usageError(`line ${index + 1}: invalid display_type ${JSON.stringify(spec.display_type)}`, "expected: line_section or line_note");
+        }
+        if (typeof spec.name !== "string" || spec.name === "") {
+            throw usageError(`line ${index + 1}: a ${spec.display_type} line requires "name"`);
+        }
+        values.display_type = spec.display_type;
+        values.name = spec.name;
+        return values;
+    }
+    if (typeof spec.product_id !== "number" || !Number.isInteger(spec.product_id)) {
+        throw usageError(`line ${index + 1}: a product line requires "product_id" (integer)`, 'or pass "display_type": "line_section"|"line_note" for section/note lines');
+    }
+    // Verify the product exists and pick up defaults (name, price) when omitted.
+    const products = (await client.executeKw("product.product", "read", [
+        [spec.product_id],
+    ], {
+        fields: ["display_name", "lst_price"],
+    }));
+    if (products.length === 0) {
+        throw notFoundError("reference_not_found", `line ${index + 1}: no product.product with id ${spec.product_id}`);
+    }
+    values.product_id = spec.product_id;
+    values.name =
+        typeof spec.name === "string" && spec.name !== ""
+            ? spec.name
+            : products[0].display_name;
+    values.product_uom_qty = spec.product_uom_qty ?? 1;
+    if (typeof values.product_uom_qty !== "number" ||
+        !Number.isFinite(values.product_uom_qty)) {
+        throw usageError(`line ${index + 1}: product_uom_qty must be a number`);
+    }
+    values.price_unit = spec.price_unit ?? products[0].lst_price;
+    if (typeof values.price_unit !== "number" || !Number.isFinite(values.price_unit)) {
+        throw usageError(`line ${index + 1}: price_unit must be a number`);
+    }
+    if (spec.tax_ids !== undefined) {
+        if (!Array.isArray(spec.tax_ids) ||
+            !spec.tax_ids.every((t) => typeof t === "number" && Number.isInteger(t))) {
+            throw usageError(`line ${index + 1}: tax_ids must be an array of integers`);
+        }
+        values.tax_id = [[6, 0, spec.tax_ids]];
+    }
+    return values;
+}
+async function buildAllLines(client, specs) {
+    const out = [];
+    for (let i = 0; i < specs.length; i++) {
+        out.push(await buildLineValues(client, specs[i], i));
+    }
+    return out;
+}
+export async function ordersListCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    if (opts.domain && opts.filter && opts.filter.length > 0) {
+        throw usageError("--domain and --filter are mutually exclusive", "pick one filtering form");
+    }
+    const limit = parseCount(opts.limit, "--limit");
+    const offset = parseCount(opts.offset, "--offset");
+    const fieldsMeta = await ModelFields.load(client, SALE_ORDER);
+    const domain = [];
+    if (opts.partner) {
+        const partner = await resolveReference(client, "res.partner", opts.partner, {
+            label: "partner",
+        });
+        domain.push(["partner_id", "=", partner.id]);
+        logVerbose(`resolved --partner "${opts.partner}" -> [${partner.id}, "${partner.name}"]`, globals.verbose);
+    }
+    if (opts.state) {
+        if (STATE_LABELS[opts.state] === undefined) {
+            throw usageError(`invalid --state ${JSON.stringify(opts.state)}`, `expected one of: ${Object.keys(STATE_LABELS).join(", ")}`);
+        }
+        domain.push(["state", "=", opts.state]);
+    }
+    if (opts.domain) {
+        domain.push(...parseDomain(opts.domain));
+    }
+    else if (opts.filter && opts.filter.length > 0) {
+        domain.push(...buildFilterClauses(opts.filter, fieldsMeta, {
+            partner_id: "--partner",
+            user_id: "--filter user_id=<id>",
+        }));
+    }
+    const fields = opts.fields ? parseFieldList(opts.fields) : LIST_FIELDS;
+    for (const field of fields) {
+        if (field !== "id" && !fieldsMeta.get(field)) {
+            throw usageError(`unknown field ${JSON.stringify(field)} on ${SALE_ORDER}`, "run `odoo sales orders read <id> --json` to see available fields");
+        }
+    }
+    const order = opts.order ?? "id desc";
+    const [records, count] = await Promise.all([
+        client.executeKw(SALE_ORDER, "search_read", [domain], {
+            fields,
+            limit,
+            offset,
+            order,
+        }),
+        client.executeKw(SALE_ORDER, "search_count", [domain]),
+    ]);
+    if (globals.json) {
+        printJson({ model: SALE_ORDER, records, count, limit, offset });
+        return;
+    }
+    const headers = fields.map((f) => fieldsMeta.get(f)?.string ?? f);
+    const rows = records.map((rec) => fields.map((f) => {
+        if (f === "state")
+            return STATE_LABELS[String(rec.state)] ?? humanCell(rec.state);
+        return humanCell(rec[f]);
+    }));
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+function parseCount(raw, flag) {
+    if (!/^\d+$/.test(raw)) {
+        throw usageError(`invalid ${flag} value ${JSON.stringify(raw)}`, "expected a non-negative integer");
+    }
+    return Number(raw);
+}
+function parseFieldList(raw) {
+    const fields = raw
+        .split(",")
+        .map((f) => f.trim())
+        .filter((f) => f !== "");
+    if (fields.length === 0) {
+        throw usageError("--fields requires at least one field name");
+    }
+    return fields;
+}
+// ---------------------------------------------------------------------------
+// orders read
+// ---------------------------------------------------------------------------
+export async function ordersReadCommand(idArg, globals) {
+    const client = await authenticatedClient(globals);
+    const id = parseId(idArg);
+    const fieldsMeta = await ModelFields.load(client, SALE_ORDER);
+    // Intersect with fields_get so edition-dependent fields degrade gracefully.
+    const fields = READ_FIELDS.filter((f) => f === "id" || fieldsMeta.get(f));
+    const rows = (await client.executeKw(SALE_ORDER, "read", [[id]], {
+        fields,
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no ${SALE_ORDER} record with id ${id}`);
+    }
+    const record = rows[0];
+    const lineIds = record.order_line ?? [];
+    const lines = lineIds.length
+        ? (await client.executeKw(SALE_ORDER_LINE, "read", [lineIds], {
+            fields: LINE_FIELDS,
+        }))
+        : [];
+    lines.sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0));
+    const partnerId = Array.isArray(record.partner_id)
+        ? record.partner_id[0]
+        : undefined;
+    const partner = partnerId
+        ? (await client.executeKw("res.partner", "read", [[partnerId]], {
+            fields: ["name", "vat", "street", "street2", "zip", "city", "country_id", "email"],
+        }))[0]
+        : undefined;
+    if (globals.json) {
+        printJson({ model: SALE_ORDER, record, order_lines: lines, partner });
+        return;
+    }
+    const color = colorEnabled(globals.noColor);
+    const pairs = [];
+    for (const f of fields) {
+        if (f === "order_line" || f === "access_token" || f === "partner_id")
+            continue;
+        const label = fieldsMeta.get(f)?.string ?? f;
+        const value = f === "state"
+            ? (STATE_LABELS[String(record.state)] ?? humanCell(record.state))
+            : humanCell(record[f]);
+        pairs.push([label, value]);
+    }
+    process.stdout.write(formatKeyValues(pairs, color) + "\n");
+    if (partner) {
+        const pp = [
+            ["Partner", humanCell(record.partner_id)],
+            ["VAT", humanCell(partner.vat)],
+            ["Street", humanCell(partner.street)],
+            ["Street 2", humanCell(partner.street2)],
+            ["Zip", humanCell(partner.zip)],
+            ["City", humanCell(partner.city)],
+            ["Country", humanCell(partner.country_id)],
+        ].filter(([, v]) => v !== "");
+        process.stdout.write("\n" + formatKeyValues(pp, color) + "\n");
+    }
+    if (lines.length > 0) {
+        const headers = ["ID", "Type", "Product", "Description", "Qty", "Unit Price", "Taxes", "Subtotal"];
+        const rowsOut = lines.map((l) => [
+            String(l.id),
+            l.display_type === "line_section"
+                ? "Section"
+                : l.display_type === "line_note"
+                    ? "Note"
+                    : "",
+            l.display_type ? "" : humanCell(l.product_id),
+            humanCell(l.name),
+            l.display_type ? "" : humanCell(l.product_uom_qty),
+            l.display_type ? "" : humanCell(l.price_unit),
+            Array.isArray(l.tax_id) ? l.tax_id.join(",") : "",
+            l.display_type ? "" : humanCell(l.price_subtotal),
+        ]);
+        process.stdout.write("\n" + formatTable(headers, rowsOut, color) + "\n");
+    }
+}
+export async function ordersCreateCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    await ModelFields.load(client, SALE_ORDER);
+    if (!opts.partner) {
+        throw usageError("missing required --partner", '--partner <id|name> (field "partner_id") is required to create a sale.order record');
+    }
+    const values = {};
+    const resolved = {};
+    const resolveM2o = async (model, input, label, field, searchFields) => {
+        const r = await resolveReference(client, model, input, {
+            label,
+            searchFields,
+        });
+        values[field] = r.id;
+        resolved[field] = [r.id, r.name];
+        logVerbose(`resolved --${label} "${input}" -> [${r.id}, "${r.name}"]`, globals.verbose);
+    };
+    await resolveM2o("res.partner", opts.partner, "partner", "partner_id");
+    if (opts.pricelist) {
+        await resolveM2o("product.pricelist", opts.pricelist, "pricelist", "pricelist_id");
+    }
+    if (opts.paymentTerms) {
+        await resolveM2o("account.payment.term", opts.paymentTerms, "payment-terms", "payment_term_id");
+    }
+    if (opts.validity) {
+        values.validity_date = parseDate(opts.validity, "--validity");
+    }
+    if (opts.opportunity) {
+        await resolveM2o("crm.lead", opts.opportunity, "opportunity", "opportunity_id");
+    }
+    if (opts.salesperson) {
+        await resolveM2o("res.users", opts.salesperson, "salesperson", "user_id", [
+            "login",
+            "email",
+            "name",
+        ]);
+    }
+    if (opts.plan) {
+        await resolveM2o(SUBSCRIPTION_PLAN, opts.plan, "plan", "plan_id");
+    }
+    if (opts.note !== undefined) {
+        values.note = opts.note;
+    }
+    let lineValues = [];
+    if (opts.lines !== undefined) {
+        const specs = await readLinesFile(opts.lines);
+        lineValues = await buildAllLines(client, specs);
+        values.order_line = lineValues.map((lv) => [0, 0, lv]);
+    }
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: SALE_ORDER,
+                action: "create",
+                dry_run: true,
+                values,
+                ...(Object.keys(resolved).length > 0 ? { resolved } : {}),
+            });
+            return;
+        }
+        const linesOut = [`Would create ${SALE_ORDER}:`];
+        for (const [field, v] of Object.entries(values)) {
+            if (field === "order_line")
+                continue;
+            const r = resolved[field];
+            linesOut.push(`  ${field}: ${r ? `[${r[0]}, ${JSON.stringify(r[1])}]` : JSON.stringify(v)}`);
+        }
+        if (lineValues.length > 0) {
+            linesOut.push(`  order_line: ${lineValues.length} line(s)`);
+            for (const lv of lineValues) {
+                linesOut.push(`    - ${JSON.stringify(lv)}`);
+            }
+        }
+        process.stdout.write(linesOut.join("\n") + "\n");
+        return;
+    }
+    const id = (await client.executeKw(SALE_ORDER, "create", [values]));
+    if (typeof id !== "number" || !Number.isInteger(id)) {
+        throw networkError(`unexpected create() response from the server: ${JSON.stringify(id)}`);
+    }
+    if (globals.json) {
+        printJson({
+            model: SALE_ORDER,
+            action: "create",
+            dry_run: false,
+            id,
+            ...(Object.keys(resolved).length > 0 ? { resolved } : {}),
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = `Created ${SALE_ORDER} ${id}`;
+    process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
+}
+export async function ordersUpdateCommand(idArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const id = parseId(idArg);
+    const fieldsMeta = await ModelFields.load(client, SALE_ORDER);
+    const entries = opts.set ?? [];
+    if (entries.length === 0) {
+        throw usageError("nothing to update", "pass at least one --set field=value");
+    }
+    const values = {};
+    for (const entry of entries) {
+        const eq = entry.indexOf("=");
+        if (eq <= 0) {
+            throw usageError(`invalid --set ${JSON.stringify(entry)}`, "expected the form field=value");
+        }
+        const field = entry.slice(0, eq);
+        // Guardrail: state transitions are a human action in the Odoo UI.
+        if (field === "state") {
+            throw usageError("refusing to set sale.order.state via the CLI", "state changes (confirm/cancel) happen in the Odoo UI by a human — update header fields only");
+        }
+        if (!UPDATABLE_HEADER_FIELDS.has(field)) {
+            throw usageError(`field ${JSON.stringify(field)} cannot be set via \`sales orders update\``, `updatable header fields: ${[...UPDATABLE_HEADER_FIELDS].join(", ")} — use \`sales lines\` for order lines`);
+        }
+        if (!fieldsMeta.get(field)) {
+            throw conflictError("unknown_field", `unknown field ${JSON.stringify(field)} on ${SALE_ORDER}`);
+        }
+        if (values[field] !== undefined) {
+            throw usageError(`field "${field}" given more than once`, "pass each field exactly once");
+        }
+        values[field] = parseFilterScalar(entry.slice(eq + 1));
+    }
+    // Read-first pass: existence check + before/after diff (mirrors mutation.ts).
+    const rows = (await client.executeKw(SALE_ORDER, "read", [[id]], {
+        fields: [...Object.keys(values), "display_name"],
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no ${SALE_ORDER} record with id ${id}`);
+    }
+    const rec = rows[0];
+    const changes = {};
+    for (const [field, after] of Object.entries(values)) {
+        const before = rec[field];
+        const meta = fieldsMeta.get(field);
+        const equal = meta?.type === "many2one"
+            ? (Array.isArray(before) ? before[0] : before) === after
+            : before === after || (before === false && after === false);
+        if (!equal)
+            changes[field] = { before, after };
+    }
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: SALE_ORDER,
+                action: "update",
+                dry_run: true,
+                changes: { [String(id)]: changes },
+            });
+            return;
+        }
+        if (Object.keys(changes).length === 0) {
+            process.stdout.write(`Unchanged ${SALE_ORDER} ${id} (${humanCell(rec.display_name)}) — nothing to change\n`);
+            return;
+        }
+        const linesOut = [`Would update ${SALE_ORDER} ${id} (${humanCell(rec.display_name)}):`];
+        for (const [field, c] of Object.entries(changes)) {
+            linesOut.push(`  ${field}: ${JSON.stringify(c.before)} -> ${JSON.stringify(c.after)}`);
+        }
+        process.stdout.write(linesOut.join("\n") + "\n");
+        return;
+    }
+    if (Object.keys(changes).length > 0) {
+        await client.executeKw(SALE_ORDER, "write", [[id], values]);
+    }
+    if (globals.json) {
+        printJson({
+            model: SALE_ORDER,
+            action: "update",
+            dry_run: false,
+            changes: { [String(id)]: changes },
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = Object.keys(changes).length === 0
+        ? `Unchanged ${SALE_ORDER} ${id}`
+        : `Updated ${SALE_ORDER} ${id}`;
+    process.stdout.write((Object.keys(changes).length === 0
+        ? line
+        : color
+            ? `\x1b[33m${line}\x1b[0m`
+            : line) + "\n");
+}
+export async function linesAddCommand(orderIdArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const orderId = parseId(orderIdArg);
+    if (opts.lines === undefined) {
+        throw usageError("missing required --lines", "pass --lines <json-file> or --lines - (stdin)");
+    }
+    const orders = (await client.executeKw(SALE_ORDER, "read", [[orderId]], {
+        fields: ["display_name", "state"],
+    }));
+    if (orders.length === 0) {
+        throw notFoundError("record_not_found", `no ${SALE_ORDER} record with id ${orderId}`);
+    }
+    const specs = await readLinesFile(opts.lines);
+    const lineValues = await buildAllLines(client, specs);
+    const withOrder = lineValues.map((lv) => ({ ...lv, order_id: orderId }));
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: SALE_ORDER_LINE,
+                action: "create",
+                dry_run: true,
+                order_id: orderId,
+                values: withOrder,
+            });
+            return;
+        }
+        const linesOut = [
+            `Would add ${withOrder.length} line(s) to ${SALE_ORDER} ${orderId} (${humanCell(orders[0].display_name)}):`,
+            ...withOrder.map((lv) => `  - ${JSON.stringify(lv)}`),
+        ];
+        process.stdout.write(linesOut.join("\n") + "\n");
+        return;
+    }
+    const ids = (await client.executeKw(SALE_ORDER_LINE, "create", [
+        withOrder,
+    ]));
+    if (!Array.isArray(ids) || !ids.every((i) => typeof i === "number")) {
+        throw networkError(`unexpected create() response from the server: ${JSON.stringify(ids)}`);
+    }
+    if (globals.json) {
+        printJson({
+            model: SALE_ORDER_LINE,
+            action: "create",
+            dry_run: false,
+            order_id: orderId,
+            ids,
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = `Created ${ids.length} ${SALE_ORDER_LINE} record(s) on ${SALE_ORDER} ${orderId}: ${ids.join(", ")}`;
+    process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
+}
+export async function linesUpdateCommand(lineIdArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const lineId = parseId(lineIdArg);
+    if (opts.lines === undefined) {
+        throw usageError("missing required --lines", "pass --lines <json-file> or --lines - (stdin) with a single line object");
+    }
+    const specs = await readLinesFile(opts.lines);
+    if (specs.length !== 1) {
+        throw usageError(`\`sales lines update\` expects exactly one line object (got ${specs.length})`);
+    }
+    const spec = specs[0];
+    const rows = (await client.executeKw(SALE_ORDER_LINE, "read", [[lineId]], {
+        fields: LINE_FIELDS,
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no ${SALE_ORDER_LINE} record with id ${lineId}`);
+    }
+    const rec = rows[0];
+    // Build the update dict from the keys present in the spec (no defaults —
+    // update never invents values the caller did not pass).
+    const values = {};
+    if (spec.display_type !== undefined) {
+        if (spec.display_type !== "line_section" && spec.display_type !== "line_note") {
+            throw usageError(`invalid display_type ${JSON.stringify(spec.display_type)}`, "expected: line_section or line_note");
+        }
+        values.display_type = spec.display_type;
+    }
+    if (spec.name !== undefined)
+        values.name = spec.name;
+    if (spec.product_id !== undefined) {
+        if (typeof spec.product_id !== "number" || !Number.isInteger(spec.product_id)) {
+            throw usageError("product_id must be an integer");
+        }
+        values.product_id = spec.product_id;
+    }
+    if (spec.product_uom_qty !== undefined) {
+        if (typeof spec.product_uom_qty !== "number" || !Number.isFinite(spec.product_uom_qty)) {
+            throw usageError("product_uom_qty must be a number");
+        }
+        values.product_uom_qty = spec.product_uom_qty;
+    }
+    if (spec.price_unit !== undefined) {
+        if (typeof spec.price_unit !== "number" || !Number.isFinite(spec.price_unit)) {
+            throw usageError("price_unit must be a number");
+        }
+        values.price_unit = spec.price_unit;
+    }
+    if (spec.tax_ids !== undefined) {
+        if (!Array.isArray(spec.tax_ids) ||
+            !spec.tax_ids.every((t) => typeof t === "number" && Number.isInteger(t))) {
+            throw usageError("tax_ids must be an array of integers");
+        }
+        values.tax_id = [[6, 0, spec.tax_ids]];
+    }
+    if (Object.keys(values).length === 0) {
+        throw usageError("nothing to update", "the line object must set at least one of: display_type, name, product_id, product_uom_qty, price_unit, tax_ids");
+    }
+    const changes = {};
+    for (const [field, after] of Object.entries(values)) {
+        const before = rec[field];
+        let equal;
+        if (field === "product_id") {
+            equal = (Array.isArray(before) ? before[0] : before) === after;
+        }
+        else if (field === "tax_id") {
+            const afterIds = after[0]?.[2] ?? [];
+            equal =
+                JSON.stringify([...(before ?? [])].sort((a, b) => a - b)) ===
+                    JSON.stringify([...afterIds].sort((a, b) => a - b));
+        }
+        else {
+            equal = before === after || (before === false && after === false);
+        }
+        if (!equal)
+            changes[field] = { before, after };
+    }
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: SALE_ORDER_LINE,
+                action: "update",
+                dry_run: true,
+                changes: { [String(lineId)]: changes },
+            });
+            return;
+        }
+        if (Object.keys(changes).length === 0) {
+            process.stdout.write(`Unchanged ${SALE_ORDER_LINE} ${lineId} — nothing to change\n`);
+            return;
+        }
+        const linesOut = [`Would update ${SALE_ORDER_LINE} ${lineId}:`];
+        for (const [field, c] of Object.entries(changes)) {
+            linesOut.push(`  ${field}: ${JSON.stringify(c.before)} -> ${JSON.stringify(c.after)}`);
+        }
+        process.stdout.write(linesOut.join("\n") + "\n");
+        return;
+    }
+    if (Object.keys(changes).length > 0) {
+        await client.executeKw(SALE_ORDER_LINE, "write", [[lineId], values]);
+    }
+    if (globals.json) {
+        printJson({
+            model: SALE_ORDER_LINE,
+            action: "update",
+            dry_run: false,
+            changes: { [String(lineId)]: changes },
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = Object.keys(changes).length === 0
+        ? `Unchanged ${SALE_ORDER_LINE} ${lineId}`
+        : `Updated ${SALE_ORDER_LINE} ${lineId}`;
+    process.stdout.write((Object.keys(changes).length === 0
+        ? line
+        : color
+            ? `\x1b[33m${line}\x1b[0m`
+            : line) + "\n");
+}
+export async function plansListCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    await ModelFields.load(client, SUBSCRIPTION_PLAN);
+    const limit = parseCount(opts.limit, "--limit");
+    const records = (await client.executeKw(SUBSCRIPTION_PLAN, "search_read", [
+        [],
+    ], {
+        fields: ["id", "name", "billing_period_value", "billing_period_unit"],
+        limit,
+        order: "id asc",
+    }));
+    if (globals.json) {
+        printJson({ model: SUBSCRIPTION_PLAN, records, count: records.length });
+        return;
+    }
+    const headers = ["ID", "Name", "Billing Period Value", "Billing Period Unit"];
+    const rows = records.map((r) => [
+        String(r.id),
+        humanCell(r.name),
+        humanCell(r.billing_period_value),
+        humanCell(r.billing_period_unit),
+    ]);
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+export async function invoicesPrecedentCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    if (!opts.product) {
+        throw usageError("missing required --product", "pass --product <id|name> (product.product)");
+    }
+    const product = await resolveReference(client, "product.product", opts.product, { label: "product" });
+    const limit = parseCount(opts.limit, "--limit");
+    const domain = [
+        ["product_id", "=", product.id],
+        ["move_id.move_type", "=", "out_invoice"],
+        ["move_id.state", "=", "posted"],
+    ];
+    const lines = (await client.executeKw("account.move.line", "search_read", [
+        domain,
+    ], {
+        fields: [
+            "id",
+            "move_id",
+            "partner_id",
+            "currency_id",
+            "quantity",
+            "price_unit",
+            "price_subtotal",
+        ],
+        limit,
+        order: "id desc",
+    }));
+    const moveIds = [
+        ...new Set(lines
+            .map((l) => (Array.isArray(l.move_id) ? l.move_id[0] : undefined))
+            .filter((i) => i !== undefined)),
+    ];
+    const moves = moveIds.length
+        ? (await client.executeKw("account.move", "read", [moveIds], {
+            fields: ["id", "name", "invoice_date"],
+        }))
+        : [];
+    const moveById = new Map(moves.map((m) => [m.id, m]));
+    const records = lines
+        .map((l) => {
+        const moveId = Array.isArray(l.move_id) ? l.move_id[0] : 0;
+        const move = moveById.get(moveId);
+        return {
+            id: l.id,
+            invoice: move?.name ?? humanCell(l.move_id),
+            invoice_date: move?.invoice_date ?? "",
+            partner_id: l.partner_id,
+            currency_id: l.currency_id,
+            quantity: l.quantity,
+            price_unit: l.price_unit,
+            price_subtotal: l.price_subtotal,
+        };
+    })
+        .sort((a, b) => String(b.invoice_date).localeCompare(String(a.invoice_date)));
+    if (globals.json) {
+        printJson({
+            model: "account.move.line",
+            product: [product.id, product.name],
+            records,
+            count: records.length,
+        });
+        return;
+    }
+    const headers = ["Invoice", "Date", "Partner", "Currency", "Qty", "Unit Price", "Subtotal"];
+    const rows = records.map((r) => [
+        r.invoice,
+        r.invoice_date,
+        humanCell(r.partner_id),
+        humanCell(r.currency_id),
+        humanCell(r.quantity),
+        humanCell(r.price_unit),
+        humanCell(r.price_subtotal),
+    ]);
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+export async function pdfCommand(idArg, opts, globals) {
+    const id = parseId(idArg);
+    if (!opts.out) {
+        throw usageError("missing required --out", "pass --out <path> for the downloaded PDF");
+    }
+    const resolved = await resolveConfig({
+        profile: globals.profile,
+        url: globals.url,
+        db: globals.db,
+        username: globals.username,
+        apiKeyFile: globals.apiKeyFile,
+    });
+    if (!resolved.url) {
+        throw usageError("missing required configuration: url");
+    }
+    const baseUrl = resolved.url.replace(/\/+$/, "");
+    const client = await authenticatedClient(globals);
+    const rows = (await client.executeKw(SALE_ORDER, "read", [[id]], {
+        fields: ["display_name", "access_token"],
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no ${SALE_ORDER} record with id ${id}`);
+    }
+    let token = rows[0].access_token || undefined;
+    if (!token) {
+        // Some records report access_token=false over XML-RPC; get_portal_url
+        // generates/returns the tokenized URL instead.
+        const portalUrl = (await client.executeKw(SALE_ORDER, "get_portal_url", [
+            [id],
+        ]));
+        if (typeof portalUrl === "string") {
+            const match = /[?&]access_token=([^&]+)/.exec(portalUrl);
+            if (match)
+                token = decodeURIComponent(match[1]);
+        }
+    }
+    if (!token) {
+        throw notFoundError("token_not_found", `could not obtain an access token for ${SALE_ORDER} ${id}`, "open the quotation in the Odoo UI and check the portal link");
+    }
+    const pdfUrl = `${baseUrl}/my/orders/${id}?access_token=${encodeURIComponent(token)}&report_type=pdf`;
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: SALE_ORDER,
+                action: "pdf",
+                dry_run: true,
+                id,
+                out: resolve(opts.out),
+                url: pdfUrl,
+            });
+            return;
+        }
+        process.stdout.write(`Would download ${SALE_ORDER} ${id} (${rows[0].display_name}) portal PDF → ${resolve(opts.out)}\n`);
+        return;
+    }
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), 60_000);
+    let response;
+    try {
+        response = await fetch(pdfUrl, { signal: abort.signal });
+    }
+    catch (cause) {
+        throw networkError(`PDF download failed: ${cause.message}`, "check connectivity and that the portal URL is reachable");
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        throw networkError(`PDF download failed: HTTP ${response.status} from ${baseUrl}`, "the access token may have been rotated — retry");
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length < 5 || buffer.subarray(0, 5).toString("latin1") !== "%PDF-") {
+        throw networkError(`downloaded file is not a PDF (got ${buffer.length} bytes, unexpected header)`, "the portal may have returned a login page — the access token may be invalid");
+    }
+    const outPath = resolve(opts.out);
+    try {
+        await stat(outPath);
+        if (!opts.force) {
+            throw usageError(`file already exists: ${outPath}`, "pass --force to overwrite");
+        }
+    }
+    catch (cause) {
+        if (cause.code !== "ENOENT")
+            throw cause;
+    }
+    await writeFile(outPath, buffer);
+    if (globals.json) {
+        printJson({
+            model: SALE_ORDER,
+            action: "pdf",
+            dry_run: false,
+            id,
+            path: outPath,
+            bytes: buffer.length,
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = `Downloaded ${SALE_ORDER} ${id} (${rows[0].display_name}) → ${outPath} (${buffer.length} bytes)`;
+    process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
+}