@bergetai/odoo-cli 0.12.0 → 0.12.2

package/dist/commands/sign.js

@@ -0,0 +1,599 @@
+import { createHash, createHmac, randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { notFoundError, usageError } from "../errors.js";
+import { resolveReference } from "../model.js";
+import { colorEnabled, printJson } from "../output.js";
+import { authenticatedClient } from "../resource.js";
+import { formatTable, humanCell } from "../table.js";
+const CONFIG_NS = "euro_office_connector";
+async function readConfigParam(client, key) {
+    const rows = (await client.executeKw("ir.config_parameter", "search_read", [
+        [["key", "=", key]],
+    ], { fields: ["value"] }));
+    return rows[0]?.value;
+}
+function signJwtHS256(secret, payload) {
+    const header = { alg: "HS256", typ: "JWT" };
+    const enc = (o) => Buffer.from(JSON.stringify(o)).toString("base64url");
+    const base = `${enc(header)}.${enc({ payload })}`;
+    const sig = createHmac("sha256", secret).update(base).digest("base64url");
+    return `${base}.${sig}`;
+}
+async function readAttachment(client, attachmentId) {
+    const rows = (await client.executeKw("ir.attachment", "read", [[attachmentId]], {
+        fields: ["name", "mimetype", "datas", "file_size"],
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("not_found", `ir.attachment ${attachmentId} not found`);
+    }
+    const row = rows[0];
+    const mimeType = row.mimetype && row.mimetype !== "text/plain"
+        ? row.mimetype
+        : guessPdfMimetype(row.name);
+    if (!row.datas) {
+        throw usageError(`attachment ${attachmentId} (${row.name}) holds no file data`);
+    }
+    const data = Buffer.from(row.datas, "base64");
+    if (mimeType === "application/pdf" && !isPdfBuffer(data)) {
+        throw usageError(`attachment ${attachmentId} (${row.name}) is not a valid PDF`);
+    }
+    return { name: row.name, mimetype: mimeType, data };
+}
+function guessPdfMimetype(name) {
+    return /\.pdf$/i.test(name)
+        ? "application/pdf"
+        : "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+}
+function isPdfBuffer(data) {
+    return data.subarray(0, 5).toString("latin1") === "%PDF-";
+}
+/**
+ * Convert a .docx (or any office file the Document Server can read) to PDF
+ * using the self-hosted OnlyOffice Document Server behind Eurooffice, whose
+ * connection settings live in ir.config_parameter.
+ */
+async function convertToPdf(client, docServerUrl, jwtSecret, contentUrl, filename) {
+    const MAX_PDF_BYTES = 50 * 1024 * 1024;
+    const body = {
+        key: `odoo-cli-${randomBytes(9).toString("hex")}`,
+        filetype: "docx",
+        outputtype: "pdf",
+        title: filename,
+        url: contentUrl,
+        async: false,
+    };
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), 60_000);
+    let response;
+    try {
+        response = await fetch(`${docServerUrl.replace(/\/+$/, "")}/ConvertService.ashx`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${signJwtHS256(jwtSecret, body)}`,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            body: JSON.stringify(body),
+            signal: abort.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        throw usageError(`OnlyOffice conversion failed: HTTP ${response.status} from ${docServerUrl}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    let pdf;
+    if (contentType.includes("application/json")) {
+        const payload = (await response.json());
+        if (!payload.fileUrl) {
+            throw usageError("OnlyOffice conversion returned no fileUrl");
+        }
+        const fetchAbort = new AbortController();
+        const fetchTimer = setTimeout(() => fetchAbort.abort(), 60_000);
+        let pdfResponse;
+        try {
+            pdfResponse = await fetch(payload.fileUrl, { signal: fetchAbort.signal });
+        }
+        finally {
+            clearTimeout(fetchTimer);
+        }
+        if (!pdfResponse.ok) {
+            throw usageError(`Could not fetch converted PDF: HTTP ${pdfResponse.status}`);
+        }
+        const size = Number(pdfResponse.headers.get("content-length") ?? 0);
+        if (size > MAX_PDF_BYTES) {
+            throw usageError(`converted PDF exceeds ${MAX_PDF_BYTES / 1024 / 1024} MB; refusing to load it into memory`);
+        }
+        pdf = Buffer.from(await pdfResponse.arrayBuffer());
+    }
+    else {
+        // Some Document Server versions answer with the binary directly.
+        const size = Number(response.headers.get("content-length") ?? 0);
+        if (size > MAX_PDF_BYTES) {
+            throw usageError(`converted PDF exceeds ${MAX_PDF_BYTES / 1024 / 1024} MB; refusing to load it into memory`);
+        }
+        pdf = Buffer.from(await response.arrayBuffer());
+    }
+    if (pdf.length === 0) {
+        throw usageError("OnlyOffice conversion produced an empty PDF");
+    }
+    return pdf;
+}
+async function resolveDocument(client, ref) {
+    const id = Number.parseInt(ref, 10);
+    if (!Number.isFinite(id)) {
+        throw usageError(`document reference must be a numeric id, got ${JSON.stringify(ref)}`);
+    }
+    const rows = (await client.executeKw("documents.document", "read", [[id]], {
+        fields: ["name", "attachment_id", "mimetype"],
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("not_found", `documents.document ${ref} not found`);
+    }
+    if (!rows[0].attachment_id) {
+        throw usageError(`documents.document ${ref} has no file attachment (URL/link document?)`);
+    }
+    return rows[0];
+}
+export async function signTemplatesListCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    const domain = opts.archived ? [] : [["active", "=", true]];
+    const records = (await client.executeKw("sign.template", "search_read", [
+        domain,
+        ["name", "active", "create_date"],
+    ], {
+        limit: Number.parseInt(opts.limit, 10) || 50,
+        order: "id asc",
+    }));
+    if (globals.json) {
+        printJson({ model: "sign.template", count: records.length, records });
+        return;
+    }
+    const headers = ["ID", "Name", "Active", "Created"];
+    const rows = records.map((t) => [
+        String(t.id),
+        humanCell(t.name),
+        t.active ? "yes" : "archived",
+        humanCell(t.create_date),
+    ]);
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+export async function signTemplatesShowCommand(idArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const id = Number.parseInt(idArg, 10);
+    const fields = opts.allFields
+        ? []
+        : ["name", "active", "attachment_id", "sign_item_ids", "create_date", "write_date"];
+    const records = (await client.executeKw("sign.template", "read", [[id]], {
+        fields: fields.length > 0 ? fields : undefined,
+    }));
+    if (records.length === 0) {
+        throw notFoundError("not_found", `sign.template ${id} not found`);
+    }
+    if (globals.json) {
+        printJson(records[0]);
+        return;
+    }
+    const rec = records[0];
+    for (const [k, v] of Object.entries(rec)) {
+        const text = Array.isArray(v) && typeof v[0] === "number"
+            ? `${v[1]} (id ${v[0]})`
+            : humanCell(v);
+        process.stdout.write(`${k.padEnd(22)} ${text}\n`);
+    }
+}
+export async function signTemplatesCreateFromDocumentCommand(docRef, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const doc = await resolveDocument(client, docRef);
+    if (!doc.attachment_id || !Array.isArray(doc.attachment_id)) {
+        throw usageError(`documents.document has no file attachment`);
+    }
+    const attachment = await readAttachment(client, doc.attachment_id[0]);
+    const needsConversion = attachment.mimetype !== "application/pdf";
+    const pdfName = needsConversion
+        ? doc.name.replace(/\.[^.]+$/, "") + ".pdf"
+        : attachment.name.replace(/\.pdf$/i, "") + ".pdf";
+    if (globals.dryRun) {
+        const preview = {
+            model: "sign.template",
+            action: "create_from_document",
+            dry_run: true,
+            document: doc.name,
+            template_name: opts.name ?? pdfName.replace(/\.pdf$/i, ""),
+            source: needsConversion
+                ? `${attachment.name} (would convert to PDF via the Document Server)`
+                : `${attachment.name} (already PDF, reused as-is)`,
+        };
+        if (globals.json) {
+            printJson(preview);
+            return;
+        }
+        process.stdout.write(`Would create sign.template "${preview.template_name}"\n  source: ${preview.source}\n`);
+        return;
+    }
+    let pdfData;
+    if (needsConversion) {
+        const docServerUrl = await readConfigParam(client, `${CONFIG_NS}.doc_server_public_url`);
+        const jwtSecret = await readConfigParam(client, `${CONFIG_NS}.doc_server_jwt_secret`);
+        const odooUrl = (await readConfigParam(client, `${CONFIG_NS}.doc_server_odoo_url`)) ??
+            globals.url;
+        if (!docServerUrl || !jwtSecret || !odooUrl) {
+            throw usageError("OnlyOffice Document Server is not configured on this instance", "expected ir.config_parameter keys euro_office_connector.doc_server_public_url, doc_server_jwt_secret, doc_server_odoo_url");
+        }
+        const token = randomBytes(24).toString("hex");
+        const tmpAttachmentId = (await client.executeKw("ir.attachment", "create", [
+            {
+                name: doc.name,
+                datas: attachment.data.toString("base64"),
+                access_token: token,
+                mimetype: attachment.mimetype,
+            },
+        ]));
+        try {
+            pdfData = await convertToPdf(client, docServerUrl, jwtSecret, `${odooUrl.replace(/\/+$/, "")}/web/content/${tmpAttachmentId}/${encodeURIComponent(doc.name)}?access_token=${token}`, doc.name);
+        }
+        finally {
+            await client.executeKw("ir.attachment", "unlink", [[tmpAttachmentId]]);
+        }
+    }
+    else {
+        pdfData = attachment.data;
+    }
+    const newAttachmentId = (await client.executeKw("ir.attachment", "create", [
+        {
+            name: pdfName,
+            datas: pdfData.toString("base64"),
+            mimetype: "application/pdf",
+            checksum: createHash("sha1").update(pdfData).digest("hex"),
+            file_size: pdfData.length,
+        },
+    ]));
+    const templateId = (await client.executeKw("sign.template", "create", [
+        { name: opts.name ?? `${pdfName.replace(/\.pdf$/i, "")}`, attachment_id: newAttachmentId },
+    ]));
+    if (globals.json) {
+        printJson({ model: "sign.template", action: "create_from_document", id: templateId, attachments: [newAttachmentId] });
+        return;
+    }
+    process.stdout.write(`Created sign.template ${templateId} (${opts.name ?? pdfName})\n`);
+}
+async function resolveSignType(client, ref) {
+    if (typeof ref === "number")
+        return ref;
+    if (/^\d+$/.test(ref))
+        return Number.parseInt(ref, 10);
+    const rows = (await client.executeKw("sign.item.type", "search_read", [
+        [["item_type", "=", ref.toLowerCase()]],
+    ], { fields: ["name"], limit: 1 }));
+    if (rows.length > 0)
+        return rows[0].id;
+    return resolveReference(client, "sign.item.type", ref, { label: "item type" }).then((r) => r.id);
+}
+async function resolveSignRole(client, ref) {
+    if (typeof ref === "number")
+        return ref;
+    if (/^\d+$/.test(ref))
+        return Number.parseInt(ref, 10);
+    const role = await resolveReference(client, "sign.item.role", ref, {
+        label: "role",
+    });
+    return role.id;
+}
+export async function signItemsAddCommand(templateRef, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const templateId = Number.parseInt(templateRef, 10);
+    let raw;
+    try {
+        raw = await readFile(opts.file, "utf8");
+    }
+    catch {
+        throw usageError(`items spec file not found: ${opts.file}`);
+    }
+    let specs;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed) || parsed.length === 0) {
+            throw new Error("expected a non-empty JSON array");
+        }
+        specs = parsed;
+    }
+    catch (error) {
+        throw usageError(`invalid items spec: ${error.message}`, 'expected JSON like [{"type":"signature","page":1,"x":10,"y":60,"width":24,"height":6,"role":"Standard","name":"Signature"}] (coordinates in % of page)');
+    }
+    const commands = [];
+    specs.forEach((spec, index) => {
+        const label = `item #${index + 1} (${JSON.stringify(spec).slice(0, 120)})`;
+        if (spec.type === undefined || spec.type === null || spec.type === "") {
+            throw usageError(`${label}: missing "type"`);
+        }
+        for (const key of ["x", "y", "width", "height"]) {
+            const value = spec[key];
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw usageError(`${label}: "${key}" must be a number`);
+            }
+            if (value < 0 || value > 100) {
+                throw usageError(`${label}: "${key}" must be within 0–100 (% of page)`);
+            }
+        }
+        if (spec.width === 0 || spec.height === 0) {
+            throw usageError(`${label}: width and height must be > 0`);
+        }
+        if (spec.page !== undefined && (!Number.isInteger(spec.page) || spec.page < 1)) {
+            throw usageError(`${label}: "page" must be an integer >= 1`);
+        }
+    });
+    for (const spec of specs) {
+        const t = await resolveSignType(client, spec.type);
+        const role = spec.role !== undefined ? await resolveSignRole(client, spec.role) : undefined;
+        commands.push([
+            0,
+            0,
+            {
+                type_id: t,
+                page: spec.page ?? 1,
+                posX: spec.x,
+                posY: spec.y,
+                width: spec.width,
+                height: spec.height,
+                required: spec.required ?? true,
+                name: spec.name,
+                ...(role !== undefined ? { responsible_id: role } : {}),
+            },
+        ]);
+    }
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({ model: "sign.item", action: "add", dry_run: true, template: templateId, count: commands.length });
+            return;
+        }
+        process.stdout.write(`Would add ${commands.length} item(s) to sign.template ${templateId}\n`);
+        return;
+    }
+    await client.executeKw("sign.template", "write", [[templateId], { sign_item_ids: commands }]);
+    const template = (await client.executeKw("sign.template", "read", [[templateId]], {
+        fields: ["name", "sign_item_ids"],
+    }));
+    if (globals.json) {
+        printJson({ model: "sign.template", action: "items_add", id: templateId, items: template[0]?.sign_item_ids.length ?? 0 });
+        return;
+    }
+    process.stdout.write(`Added ${commands.length} item(s); sign.template ${templateId} now has ${template[0]?.sign_item_ids.length ?? 0}\n`);
+}
+export async function signRequestsCreateCommand(templateRef, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const templateId = Number.parseInt(templateRef, 10);
+    const templates = (await client.executeKw("sign.template", "read", [[templateId]], {
+        fields: ["name", "attachment_id"],
+    }));
+    if (templates.length === 0) {
+        throw notFoundError("not_found", `sign.template ${templateId} not found`);
+    }
+    const template = templates[0];
+    if (!template.attachment_id || !Array.isArray(template.attachment_id)) {
+        throw usageError(`sign.template ${templateId} has no attachment; (re)create it with sign templates create-from-document`);
+    }
+    const signerCount = opts.signer?.length ?? 0;
+    const roleCount = opts.role?.length ?? 0;
+    const state = opts.state ?? "shared";
+    if (state === "shared") {
+        if (signerCount > 0 || opts.confirmSend) {
+            throw usageError("shared (draft) requests are anonymous by design", "omit --signer, or use --state sent with --roles and --confirm-send");
+        }
+        if (roleCount !== 1) {
+            throw usageError("shared requests need exactly one role: --role <name|id>", "a shared link allows anyone with the link to sign as that role");
+        }
+        // A shared request can only carry ONE anonymous signer, while the
+        // server demands one signer per template role — so multi-role
+        // templates must go through --state sent (or a single-role template).
+        const templateItems = (await client.executeKw("sign.item", "search_read", [
+            [["template_id", "=", templateId]],
+        ], { fields: ["responsible_id"] }));
+        const roleIds = new Set(templateItems
+            .map((i) => (Array.isArray(i.responsible_id) ? i.responsible_id[0] : undefined))
+            .filter((v) => typeof v === "number"));
+        if (roleIds.size > 1) {
+            throw usageError(`this template has ${roleIds.size} roles; a shared link can only serve one`, "build a single-role template, or preview the send with --state sent --dry-run before --confirm-send");
+        }
+        const roleId = await resolveSignRole(client, opts.role?.[0] ?? "");
+        const accessToken = randomBytes(16).toString("hex");
+        const requestId = (await client.executeKw("sign.request", "create", [
+            {
+                template_id: templateId,
+                reference: `Sign link — ${template.name}`,
+                state: "shared",
+                access_token: accessToken,
+                request_item_ids: [
+                    [0, 0, { role_id: roleId, access_token: randomBytes(16).toString("hex") }],
+                ],
+            },
+        ]));
+        const items = (await client.executeKw("sign.request.item", "search_read", [
+            [["sign_request_id", "=", requestId]],
+        ], { fields: ["access_token"] }));
+        const signUrl = `${await odooBaseUrl(client, globals)}/sign/document/${requestId}/${items[0]?.access_token ?? ""}`;
+        if (globals.json) {
+            printJson({ model: "sign.request", action: "create", id: requestId, state: "shared", sign_url: signUrl });
+            return;
+        }
+        process.stdout.write(`Created shared sign request ${requestId} (no email sent)\nSign link: ${signUrl}\n`);
+        return;
+    }
+    if (state !== "sent") {
+        throw usageError("--state must be 'shared' or 'sent'");
+    }
+    if (signerCount === 0 || signerCount !== roleCount) {
+        throw usageError("--state sent needs one --signer <partner> per --role <role> (repeat both)");
+    }
+    if (!opts.subject) {
+        throw usageError("--state sent requires --subject");
+    }
+    if (!opts.confirmSend) {
+        throw usageError("sending emails to signers is a sharp operation", "re-run with --confirm-send (or --dry-run to preview)");
+    }
+    const signerIds = [];
+    const signerEmails = [];
+    for (let i = 0; i < signerCount; i++) {
+        const partner = await resolveReference(client, "res.partner", opts.signer?.[i] ?? "", {
+            label: "signer",
+            searchFields: ["email", "name"],
+        });
+        const role = await resolveSignRole(client, opts.role?.[i] ?? "");
+        signerIds.push([0, 0, { partner_id: partner.id, role_id: role, mail_sent_order: 0 }]);
+        const row = (await client.executeKw("res.partner", "read", [[partner.id]], {
+            fields: ["email"],
+        }));
+        if (row[0]?.email)
+            signerEmails.push(row[0].email.toLowerCase());
+    }
+    if (globals.dryRun) {
+        const payload = {
+            template_id: templateId,
+            filename: template.attachment_id[1],
+            subject: opts.subject,
+            message: opts.message ?? "",
+            signer_ids: signerIds,
+        };
+        if (globals.json) {
+            printJson({ model: "sign.send.request", action: "send", dry_run: true, values: payload });
+            return;
+        }
+        process.stdout.write(`Would send sign request via wizard:\n` +
+            Object.entries(payload)
+                .map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`)
+                .join("\n") +
+            "\n");
+        return;
+    }
+    // The wizard requires BOTH signer_ids (one row per signer) AND signer_id
+    // (the primary partner); without signer_id, send_request() faults with
+    // "empty partner" even though signer_ids are set (build quirk, 2026-09-23).
+    const primaryPartner = (await resolveReference(client, "res.partner", opts.signer?.[0] ?? "", {
+        label: "signer",
+        searchFields: ["email", "name"],
+    })).id;
+    const wizardId = (await client.executeKw("sign.send.request", "create", [
+        {
+            template_id: templateId,
+            filename: template.attachment_id[1],
+            subject: opts.subject,
+            message: opts.message ?? "",
+            signer_id: primaryPartner,
+            signer_ids: signerIds,
+        },
+    ]));
+    const action = (await client.executeKw("sign.send.request", "send_request", [
+        [wizardId],
+    ]));
+    const requestId = action?.context?.id;
+    if (!requestId) {
+        throw usageError("send_request returned no request id — inspect the wizard state");
+    }
+    // The wizard created the sign.request in the same transaction — surface
+    // its id (the `sign requests cancel <id>` safety valve is useless without
+    // it) and anchor the mail audit to the SERVER timestamp on that request.
+    const created = (await client.executeKw("sign.request", "read", [
+        [requestId],
+    ], {
+        fields: ["reference", "state", "create_date", "access_token", "request_item_ids"],
+    }));
+    const request = created[0];
+    const mails = (await client.executeKw("mail.mail", "search_read", [
+        [["create_date", ">=", request?.create_date ?? ""], ["subject", "=", opts.subject]],
+    ], { fields: ["email_to", "subject", "state"] }));
+    const scoped = mails.filter((m) => signerEmails.some((e) => (m.email_to ?? "").toLowerCase().includes(e)));
+    const signerItems = request
+        ? (await client.executeKw("sign.request.item", "read", [request.request_item_ids], {
+            fields: ["partner_id", "access_token", "state"],
+        }))
+        : [];
+    const baseUrl = await odooBaseUrl(client, globals);
+    if (globals.json) {
+        printJson({
+            model: "sign.send.request",
+            action: "send",
+            wizard: wizardId,
+            sign_request: request?.id,
+            mails_queued: scoped.length,
+            mails: scoped,
+            sign_urls: signerItems.map((i) => `${baseUrl}/sign/document/${request?.id}/${i.access_token}`),
+        });
+        return;
+    }
+    process.stdout.write(`Sent signature request for ${template.name}\n`);
+    if (request) {
+        process.stdout.write(`sign.request ${request.id} (state: ${request.state}) — cancel with: odoo sign requests cancel ${request.id}\n`);
+        for (const item of signerItems) {
+            process.stdout.write(`  link ${item.partner_id[1]}: ${baseUrl}/sign/document/${request.id}/${item.access_token}\n`);
+        }
+    }
+    if (scoped.length < signerCount) {
+        process.stdout.write(`WARNING: only ${scoped.length}/${signerCount} expected mails found in queue — check the outgoing mail queue\n`);
+    }
+    for (const mail of scoped) {
+        process.stdout.write(`  mail -> ${mail.email_to} [${mail.state}]\n`);
+    }
+}
+async function odooBaseUrl(client, globals) {
+    // web.base.url is the public URL signers open; the connector's
+    // doc_server_odoo_url may be an internal address. Only fall back to
+    // internals when nothing better is configured.
+    const publicBase = await readConfigParam(client, "web.base.url");
+    const internalBase = await readConfigParam(client, `${CONFIG_NS}.doc_server_odoo_url`);
+    const base = publicBase ?? globals.url ?? internalBase ?? "";
+    if (!base) {
+        throw usageError("cannot determine the public Odoo URL for the sign link", "set web.base.url in the system parameters or pass --url");
+    }
+    return base.replace(/\/+$/, "");
+}
+export async function signRequestsListCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    const domain = [];
+    if (opts.state)
+        domain.push(["state", "=", opts.state]);
+    const records = (await client.executeKw("sign.request", "search_read", [
+        domain,
+        ["reference", "state", "nb_wait", "nb_total", "create_date"],
+    ], {
+        limit: Number.parseInt(opts.limit, 10) || 30,
+        order: "id desc",
+    }));
+    if (globals.json) {
+        printJson({ model: "sign.request", count: records.length, records });
+        return;
+    }
+    const headers = ["ID", "Reference", "State", "Waiting", "Signers", "Created"];
+    const rows = records.map((r) => [
+        String(r.id),
+        humanCell(r.reference),
+        r.state,
+        String(r.nb_wait),
+        `${r.nb_total - r.nb_wait}/${r.nb_total}`,
+        humanCell(r.create_date),
+    ]);
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+export async function signRequestsCancelCommand(idArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const id = Number.parseInt(idArg, 10);
+    const rows = (await client.executeKw("sign.request", "read", [[id]], {
+        fields: ["state", "reference"],
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("not_found", `sign.request ${id} not found`);
+    }
+    if (rows[0].state === "completed" || rows[0].state === "canceled") {
+        throw usageError(`sign.request ${id} is already ${rows[0].state}; nothing to cancel`);
+    }
+    if (globals.dryRun) {
+        process.stdout.write(`Would cancel sign.request ${id} (${rows[0].reference})\n`);
+        return;
+    }
+    await client.executeKw("sign.request", "write", [[id], { state: "canceled" }]);
+    if (opts.json || globals.json) {
+        printJson({ model: "sign.request", action: "cancel", id, state: "canceled" });
+        return;
+    }
+    process.stdout.write(`Canceled sign.request ${id} (${rows[0].reference})\n`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bergetai/odoo-cli",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Agent-first CLI for the Odoo External API",
   "publishConfig": {
     "access": "public"