@bergetai/odoo-cli 0.12.7 → 0.13.1

package/README.md

@@ -97,6 +97,17 @@ odoo attachments download 31337 --out ./spec.pdf
 odoo attachments delete 31337 --dry-run
 odoo attachments delete 31337
 
+# Expenses (hr.expense) — receipts attached as ir.attachment
+odoo expenses list --json
+odoo expenses show 137
+odoo expenses categories --json
+odoo expenses create --name "Taxi Arlanda" --date 2026-10-14 --amount 249.50 \
+  --currency SEK --category "Travel & Accommodation" --attach receipt.pdf --dry-run
+odoo expenses create --name "Taxi Arlanda" --date 2026-10-14 --amount 249.50 \
+  --category "Travel & Accommodation" --attach receipt.pdf
+odoo expenses attach 137 --file kvitto.pdf
+odoo expenses delete 137 --dry-run
+
 # Marketing (mailing.*) — email is the key; trace deletion is always explicit
 odoo marketing lists list
 odoo marketing lists show 11

package/dist/cli.js

@@ -12,6 +12,7 @@ import { versionCommand } from "./commands/version.js";
 import { partnersCreateCommand, partnersDeleteCommand, partnersListCommand, partnersShowCommand, partnersTagsCommand, partnersUpdateCommand, resPartner, } from "./commands/partners.js";
 import { usersDeleteCommand, usersShowCommand, } from "./commands/users.js";
 import { attachmentsDeleteCommand, attachmentsDownloadCommand, attachmentsListCommand, attachmentsShowCommand, } from "./commands/attachments.js";
+import { expensesAttachCommand, expensesCategoriesCommand, expensesCreateCommand, expensesDeleteCommand, expensesListCommand, expensesShowCommand, } from "./commands/expenses.js";
 import { signTemplatesCreateFromDocumentCommand, signTemplatesListCommand, signTemplatesShowCommand, signItemsAddCommand, signRequestsCreateCommand, signRequestsListCommand, signRequestsCancelCommand, } from "./commands/sign.js";
 import { invoicesPrecedentCommand, linesAddCommand, linesUpdateCommand, ordersCreateCommand, ordersListCommand, ordersReadCommand, ordersUpdateCommand, pdfCommand, plansListCommand, plansPricingCreateCommand, plansPricingListCommand, plansPricingUpdateCommand, } from "./commands/sales.js";
 import { messagesDeleteCommand, messagesListCommand, messagesScrubCommand, messagesShowCommand, } from "./commands/messages.js";
@@ -823,6 +824,96 @@ Examples:
         .action(async (ids) => {
         await run((g) => attachmentsDeleteCommand(ids, g), program);
     });
+    const expenses = program
+        .command("expenses")
+        .description("Expenses app (hr.expense, Enterprise) — receipts and outlays");
+    expenses
+        .command("list")
+        .description("list expenses; record rules scope visibility to own expenses unless Expense Manager")
+        .option("--filter <f=v>", "equality filter; repeatable, AND-ed", collect, [])
+        .option("--domain <json>", "Odoo domain as a JSON array (mutually exclusive with --filter)")
+        .option("--fields <a,b,c>", "columns to display")
+        .option("--limit <n>", "max records (default: 50)", "50")
+        .option("--offset <n>", "skip the first n records", "0")
+        .option("--order <order>", 'sort order, e.g. "date desc"', "date desc")
+        .addHelpText("after", `
+Examples:
+  $ odoo expenses list --json
+  $ odoo expenses list --filter state=draft
+  $ odoo expenses list --domain '[["date",">=","2026-01-01"]]' --json`)
+        .action(async (opts) => {
+        await run((g) => expensesListCommand(opts, g), program);
+    });
+    expenses
+        .command("show")
+        .description("read one expense")
+        .argument("<id>", "record id")
+        .option("--fields <a,b,c>", "fields to display")
+        .option("--all-fields", "display every readable field")
+        .action(async (id, opts) => {
+        await run((g) => expensesShowCommand(id, opts, g), program);
+    });
+    expenses
+        .command("categories")
+        .description("list expense categories (product.product where can_be_expensed)")
+        .option("--limit <n>", "max records (default: 50)", "50")
+        .option("--offset <n>", "skip the first n records", "0")
+        .action(async (opts) => {
+        await run((g) => expensesCategoriesCommand(opts, g), program);
+    });
+    expenses
+        .command("create")
+        .description("create an expense, optionally attaching one or more receipt files")
+        .requiredOption("--name <text>", "short description, e.g. 'Taxi Arlanda'")
+        .requiredOption("--date <yyyy-mm-dd>", "receipt date")
+        .requiredOption("--amount <n>", "total amount incl. VAT, e.g. 249.50")
+        .requiredOption("--category <name|id>", "expense category (see 'expenses categories')")
+        .option("--currency <code>", "currency code, e.g. SEK (default: company currency)")
+        .option("--payment-mode <mode>", "own (employee to reimburse, default) or company (company card)")
+        .option("--employee <name|id>", "expense owner (default: employee linked to the authenticated user)")
+        .option("--description <text>", "internal note / details")
+        .option("--attach <file>", "receipt file to attach (pdf/jpg/png/...); repeatable", collect, [])
+        .addHelpText("after", `
+The receipt file(s) are stored as ir.attachment rows linked to the expense
+(res_model=hr.expense), the same way the web UI stores dropped files.
+
+Examples:
+  $ odoo expenses create --name "Taxi Arlanda" --date 2026-10-14 \\
+      --amount 249.50 --currency SEK --category "Travel & Accommodation" \\
+      --attach receipt.pdf --dry-run
+  $ odoo expenses create --name "Lunch kundmöte" --date 2026-10-10 \\
+      --amount 342 --category Meals --attach kvitto1.jpg --attach kvitto2.jpg --json`)
+        .action(async (opts) => {
+        await run((g) => expensesCreateCommand(opts, g), program);
+    });
+    expenses
+        .command("attach")
+        .description("attach a receipt file to an existing expense")
+        .argument("<id>", "expense id")
+        .requiredOption("--file <path>", "receipt file (pdf/jpg/png/...)")
+        .option("--name <name>", "attachment name (default: file basename)")
+        .addHelpText("after", `
+Example:
+  $ odoo expenses attach 42 --file kvitto.pdf --dry-run
+  $ odoo expenses attach 42 --file kvitto.pdf`)
+        .action(async (id, opts) => {
+        await run((g) => expensesAttachCommand(id, opts, g), program);
+    });
+    expenses
+        .command("delete")
+        .description("delete expenses (preview with --dry-run; attachments are NOT removed, use 'attachments delete')")
+        .argument("<id...>", "record ids")
+        .addHelpText("after", `
+Note: receipt files (ir.attachment) are soft-linked and survive expense
+deletion — remove them explicitly via 'attachments list --res-model
+hr.expense --res-id <id>' + 'attachments delete'.
+
+Example:
+  $ odoo expenses delete 137 --dry-run
+  $ odoo expenses delete 137`)
+        .action(async (ids) => {
+        await run((g) => expensesDeleteCommand(ids, g), program);
+    });
     const sign = program
         .command("sign")
         .description("Sign app (sign.template, sign.request) — safe signing pipeline");

package/dist/commands/expenses.js

@@ -0,0 +1,281 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { ModelFields, resolveReference } from "../model.js";
+import { authenticatedClient, listCommand, parseId, showCommand, } from "../resource.js";
+import { parseDate, parseDecimal, deleteCommand } from "../mutation.js";
+import { notFoundError, usageError } from "../errors.js";
+import { colorEnabled, printJson } from "../output.js";
+/**
+ * Expenses app (hr.expense, Enterprise). Record rules limit visibility to
+ * own expenses unless the user is an Expense Manager — list output is
+ * therefore per-user by design.
+ *
+ * Receipt files are stored as plain ir.attachment rows with
+ * res_model="hr.expense" / res_id=<expense id> (the same mechanism the web
+ * UI uses when you drop a file on an expense).
+ */
+export const hrExpense = {
+    model: "hr.expense",
+    showCommand: "odoo expenses show",
+    defaultListFields: [
+        "id",
+        "name",
+        "date",
+        "total_amount",
+        "currency_id",
+        "product_id",
+        "payment_mode",
+        "state",
+    ],
+    showExtraFields: [
+        "description",
+        "employee_id",
+        "unit_amount",
+        "quantity",
+        "tax_ids",
+        "sheet_id",
+        "write_date",
+    ],
+    resolutionHints: {
+        product_id: "--category",
+        employee_id: "--employee",
+    },
+    priorityLabels: {},
+    pinnedDomain: [],
+    references: {},
+};
+export function expensesListCommand(opts, globals) {
+    return listCommand(hrExpense, opts, globals);
+}
+export function expensesShowCommand(idArg, opts, globals) {
+    return showCommand(hrExpense, idArg, opts, globals);
+}
+export function expensesDeleteCommand(idArgs, globals) {
+    return deleteCommand(hrExpense, idArgs, globals);
+}
+export async function expensesCategoriesCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    const limit = Number(opts.limit);
+    const offset = Number(opts.offset);
+    if (!Number.isInteger(limit) || limit < 0)
+        throw usageError(`invalid --limit value ${JSON.stringify(opts.limit)}`);
+    if (!Number.isInteger(offset) || offset < 0)
+        throw usageError(`invalid --offset value ${JSON.stringify(opts.offset)}`);
+    const domain = [["can_be_expensed", "=", true]];
+    const records = (await client.executeKw("product.product", "search_read", [
+        domain,
+    ], {
+        fields: ["id", "name", "standard_price"],
+        limit,
+        offset,
+        order: "name asc",
+    }));
+    if (globals.json) {
+        printJson({ model: "product.product", records, count: records.length, limit, offset });
+        return;
+    }
+    for (const r of records) {
+        process.stdout.write(`${r.id}\t${r.name}\n`);
+    }
+}
+// create — expense + optional receipt file attachments
+// ---------------------------------------------------------------------------
+const MIME_BY_EXT = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    ".txt": "text/plain",
+};
+const PAYMENT_MODES = {
+    own: "own_account",
+    company: "company_account",
+};
+/** Find the hr.employee linked to the authenticated user (default owner). */
+async function currentEmployee(client) {
+    const uid = await client.authenticate();
+    const rows = (await client.executeKw("hr.employee", "search_read", [
+        [["user_id", "=", uid]],
+    ], { fields: ["id"], limit: 1 }));
+    if (rows.length === 0) {
+        throw notFoundError("employee_not_found", "no hr.employee record linked to the authenticated user", "pass --employee explicitly, or link an employee to your user in Odoo");
+    }
+    return rows[0].id;
+}
+async function prepareAttachment(file) {
+    const filePath = resolve(file);
+    let fileStat;
+    try {
+        fileStat = await stat(filePath);
+    }
+    catch {
+        throw usageError(`file not found: ${file}`);
+    }
+    if (!fileStat.isFile())
+        throw usageError(`not a regular file: ${file}`);
+    const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+    const buffer = await readFile(filePath);
+    return {
+        path: filePath,
+        name: basename(filePath),
+        mimetype: MIME_BY_EXT[ext] ?? "application/octet-stream",
+        datas: buffer.toString("base64"),
+        size: fileStat.size,
+    };
+}
+export async function expensesCreateCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    await ModelFields.load(client, "hr.expense");
+    const date = parseDate(opts.date, "--date");
+    const amount = parseDecimal(opts.amount, "--amount");
+    if (amount <= 0) {
+        throw usageError("--amount must be greater than zero");
+    }
+    const category = await resolveReference(client, "product.product", opts.category, {
+        label: "expense category",
+        domain: [["can_be_expensed", "=", true]],
+    });
+    const paymentMode = opts.paymentMode !== undefined
+        ? (() => {
+            const key = opts.paymentMode.toLowerCase();
+            const mode = PAYMENT_MODES[key] ??
+                (Object.values(PAYMENT_MODES).includes(key) ? key : undefined);
+            if (mode === undefined) {
+                throw usageError(`invalid --payment-mode ${JSON.stringify(opts.paymentMode)}`, `expected one of: ${Object.keys(PAYMENT_MODES).join(", ")} (own = employee to reimburse, company = company card)`);
+            }
+            return mode;
+        })()
+        : "own_account";
+    const currency = opts.currency !== undefined
+        ? await resolveReference(client, "res.currency", opts.currency, {
+            label: "currency",
+            exactFields: ["name"],
+        })
+        : undefined;
+    const employeeId = opts.employee !== undefined
+        ? (await resolveReference(client, "hr.employee", opts.employee, {
+            label: "employee",
+        })).id
+        : await currentEmployee(client);
+    const attachments = [];
+    for (const file of opts.attach ?? []) {
+        attachments.push(await prepareAttachment(file));
+    }
+    const values = {
+        name: opts.name,
+        date,
+        total_amount: amount,
+        product_id: category.id,
+        payment_mode: paymentMode,
+        employee_id: employeeId,
+    };
+    if (currency !== undefined)
+        values.currency_id = currency.id;
+    if (opts.description !== undefined)
+        values.description = opts.description;
+    if (globals.dryRun) {
+        const preview = {
+            ...values,
+            attachments: attachments.map((a) => `${a.name} (${a.size} bytes)`),
+        };
+        if (globals.json) {
+            printJson({ model: "hr.expense", action: "create", dry_run: true, values: preview });
+            return;
+        }
+        process.stdout.write(`Would create hr.expense:\n` +
+            Object.entries(preview)
+                .map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`)
+                .join("\n") +
+            "\n");
+        return;
+    }
+    const id = (await client.executeKw("hr.expense", "create", [values]));
+    const uploaded = [];
+    for (const a of attachments) {
+        const attId = (await client.executeKw("ir.attachment", "create", [
+            {
+                name: a.name,
+                mimetype: a.mimetype,
+                datas: a.datas,
+                res_model: "hr.expense",
+                res_id: id,
+            },
+        ]));
+        uploaded.push({ id: attId, name: a.name });
+    }
+    if (globals.json) {
+        printJson({
+            model: "hr.expense",
+            action: "create",
+            dry_run: false,
+            id,
+            name: opts.name,
+            attachments: uploaded,
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const attSuffix = uploaded.length > 0 ? ` + ${uploaded.length} attachment(s)` : "";
+    const line = `Created hr.expense ${id} (${opts.name})${attSuffix}`;
+    process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
+}
+export async function expensesAttachCommand(idArg, opts, globals) {
+    const id = parseId(idArg);
+    const client = await authenticatedClient(globals);
+    // Verify the expense exists (and is visible under record rules).
+    const rows = (await client.executeKw("hr.expense", "read", [[id]], {
+        fields: ["name"],
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no hr.expense record with id ${id}`, "expenses are only visible to their owner unless you are an Expense Manager");
+    }
+    const prepared = await prepareAttachment(opts.file);
+    const name = opts.name ?? prepared.name;
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: "ir.attachment",
+                action: "attach",
+                dry_run: true,
+                values: {
+                    name,
+                    mimetype: prepared.mimetype,
+                    res_model: "hr.expense",
+                    res_id: id,
+                    datas: `<${prepared.size} bytes base64>`,
+                },
+            });
+            return;
+        }
+        process.stdout.write(`Would attach ${name} (${prepared.size} bytes) to hr.expense ${id}\n`);
+        return;
+    }
+    const attId = (await client.executeKw("ir.attachment", "create", [
+        {
+            name,
+            mimetype: prepared.mimetype,
+            datas: prepared.datas,
+            res_model: "hr.expense",
+            res_id: id,
+        },
+    ]));
+    if (globals.json) {
+        printJson({
+            model: "ir.attachment",
+            action: "attach",
+            dry_run: false,
+            id: attId,
+            name,
+            res_model: "hr.expense",
+            res_id: id,
+            file_size: prepared.size,
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = `Attached ${name} to hr.expense ${id} (ir.attachment ${attId})`;
+    process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
+}

package/package.json

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