@bergetai/odoo-cli 0.12.6 → 0.13.1

package/README.md

@@ -46,6 +46,8 @@ odoo models fields res.partner --filter "^email" --json
 odoo models fields crm.lead --custom              # only x_* custom fields
 odoo models read res.partner --ids 51,52 --fields name,city
 odoo models read crm.lead --search "microsoft" --json  # ilike on name (max 100)
+odoo models search mail.activity --domain '[["user_id","=",39],["date_deadline","<=","2026-09-25"]]' --json
+odoo models search mail.activity --filter user_id=39 --fields res_id,summary,date_deadline --json
 
 # List and inspect records
 odoo crm leads list --open --limit 20
@@ -95,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
@@ -184,7 +197,7 @@ Note: `odoo --version` prints the CLI's own version; `odoo version` queries the
 - Read-only Helpdesk surface (`helpdesk tickets list/show`) — `--open`/`--closed` via stage `fold`, strict team-scoped stage resolution, module-not-installed error (exit 4)
 - Read-only Project surface (`project list/show`) — `--user` (project manager) and `--tag` filters, archived projects excluded by default, module-not-installed error (exit 4)
 - Read-only Project task surface (`project tasks list/show`) — `--project` (required on list, resolved by name or id), project-scoped `--stage`, `--assignee` (many2many `user_ids`), `--tag`, `--priority` (0/Low, 1/High), `--open`/`--closed` via the task's `is_closed` flag, `--domain`/`--filter`, table/JSON output with `search_count` envelope, module-not-installed error (exit 4)
-- Generic model surface (`models fields/read`) — introspect and read any model exposed through `execute_kw`: `fields` lists `fields_get` metadata (type, label, selection, relation, required, store) with `--filter <regex>` (case-insensitive on field name or label) and `--custom` (only `x_*` fields); `read` fetches up to 100 records by `--ids 1,2,3` or a name ilike `--search`, with `--fields a,b,c` (default: name). Unknown models/fields use the standard error taxonomy
+- Generic model surface (`models fields/read/search`) — introspect, read and search any model exposed through `execute_kw`: `fields` lists `fields_get` metadata (type, label, selection, relation, required, store) with `--filter <regex>` (case-insensitive on field name or label) and `--custom` (only `x_*` fields); `read` fetches up to 100 records by `--ids 1,2,3` or a name ilike `--search`, with `--fields a,b,c` (default: name); `search` runs an arbitrary domain via `--domain <json>` (or repeatable `--filter f=v`, mutually exclusive) with `--fields` (default: id[,name]), `--limit`/`--offset`/`--order`, and `--include-archived` (runs with `active_test: false`; eager-fetches rows other list engines hide by default). Unknown models/fields use the standard error taxonomy
 - Documents surface (`documents`) — `tree` (hierarchical folder listing with `--count`/`--depth`/`--folder`), `records list/show` (folders excluded by default, `--type folder|binary|url|all`, `--folder`/`--owner`/`--partner`/`--tag`), `folders list`, `records create` (folder via `--folder-type folder`, link via `--link <url>`), `records update` (move via `--folder`), `records delete`, `upload` (local file → base64 `datas`, MIME guessed from extension, `--dry-run` previews without sending bytes), and `records download <id>` (binary document → local file, `--out <path>`/`--force`, `--out -` streams to stdout). Everywhere a `--folder` is accepted, folders resolve by name, numeric id, or nested `'Parent > Child'` path (segments resolved within their parent, which disambiguates repeated folder names). Folders are `documents.document` rows with `type='folder'`; the hierarchy is `folder_id`. Module-not-installed error (exit 4)
 - Writes (`create`, `update`, `delete`) — single-call atomic batch `write`, client-side no-op diffing, delete convergence with `skipped` ids, post-failure "record may have been created" hint on `create`
 - `--dry-run` for all mutations — full validation, resolution, and before/after diffs without mutating

package/dist/cli.js

@@ -12,11 +12,12 @@ 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";
 import { contactsDeleteCommand, contactsListCommand, contactsShowCommand, listsListCommand, listsShowCommand, tracesDeleteCommand, tracesListCommand, tracesShowCommand, } from "./commands/marketing.js";
-import { modelsFieldsCommand, modelsReadCommand, } from "./commands/models.js";
+import { modelsFieldsCommand, modelsReadCommand, modelsSearchCommand, } from "./commands/models.js";
 import { footprintCommand, } from "./commands/footprint.js";
 import { CliError } from "./errors.js";
 import { applyGlobalOptions, enforceTransportSecurity, DEFAULT_TIMEOUT, } from "./global-options.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");
@@ -1373,6 +1464,25 @@ Examples:
         .action(async (model, opts) => {
         await run((g) => modelsReadCommand(model, opts, g), program);
     });
+    models
+        .command("search")
+        .description("search records by domain (search_read; use --fields, --limit, --order)")
+        .argument("<model>", "model technical name, e.g. mail.activity")
+        .option("--domain <json>", 'Odoo domain as a JSON array, e.g. [["date_deadline","<=","2026-01-31"]]')
+        .option("--filter <field=value>", "equality filter on raw values (repeatable); many2one values must be numeric ids", collect, [])
+        .option("--fields <a,b,c>", "fields to fetch (default: id[,name])")
+        .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_deadline asc"')
+        .option("--include-archived", "match archived records too (runs with active_test: false)")
+        .addHelpText("after", `
+Examples:
+  $ odoo models search mail.activity --domain '[["user_id","=",39],["date_deadline","<=","2026-09-25"]]' --json
+  $ odoo models search mail.activity --filter user_id=39 --fields res_id,summary,date_deadline --json
+  $ odoo models search crm.lead --domain '[["team_id","=",2]]' --order "create_date desc" --limit 20 --json`)
+        .action(async (model, opts) => {
+        await run((g) => modelsSearchCommand(model, opts, g), program);
+    });
     return program;
 }
 async function run(fn, program) {

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/dist/commands/models.js

@@ -1,9 +1,16 @@
+import { buildFilterClauses, parseDomain } from "../filter.js";
 import { notFoundError, usageError } from "../errors.js";
 import { fieldsGet, ModelFields } from "../model.js";
 import { colorEnabled, printJson } from "../output.js";
 import { authenticatedClient } from "../resource.js";
 import { formatTable, humanCell } from "../table.js";
 const MAX_READ = 100;
+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(",")
@@ -125,3 +132,54 @@ export async function modelsReadCommand(model, opts, globals) {
     const rows = records.map((r) => fields.map((f) => humanCell(r[f])));
     process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
 }
+/**
+ * `models search <model>` — generic domain search over any model reachable
+ * through execute_kw. The read-side counterpart to `models read` when the
+ * name-ilike search is not enough: arbitrary domains via JSON --domain, or
+ * another model's filter surface via repeatable --filter f=v (id equality on
+ * many2one fields). Sqlite-style paging via --limit/--offset; ordering via
+ * --order. --include-archived disables active_test so archived rows are
+ * matched; on models without an `active` field it is a no-op.
+ */
+export async function modelsSearchCommand(model, opts, globals) {
+    if (opts.domain !== undefined && 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 client = await authenticatedClient(globals);
+    const meta = await ModelFields.load(client, model);
+    const domain = [];
+    if (opts.domain !== undefined) {
+        domain.push(...parseDomain(opts.domain));
+    }
+    else if (opts.filter && opts.filter.length > 0) {
+        domain.push(...buildFilterClauses(opts.filter, meta, {}, `run \`odoo models fields ${model}\` to list available fields`));
+    }
+    const defaultFields = meta.get("name") ? ["id", "name"] : ["id"];
+    const fields = opts.fields !== undefined ? parseFieldList(opts.fields) : defaultFields;
+    for (const field of fields) {
+        if (field !== "id" && !meta.get(field)) {
+            throw usageError(`unknown field ${JSON.stringify(field)} on ${model}`, "run `odoo models fields <model>` to list available fields");
+        }
+    }
+    const context = opts.includeArchived
+        ? { active_test: false }
+        : undefined;
+    const kwargs = { fields, limit, offset, order: opts.order ?? "id asc" };
+    if (context)
+        kwargs.context = context;
+    const [records, count] = await Promise.all([
+        client.executeKw(model, "search_read", [domain], kwargs),
+        client.executeKw(model, "search_count", [domain], {
+            ...(context ? { context } : {}),
+        }),
+    ]);
+    if (globals.json) {
+        printJson({ model, records, count, limit, offset });
+        return;
+    }
+    const headers = fields.map((f) => meta.get(f)?.string ?? f);
+    const rows = records.map((r) => fields.map((f) => humanCell(r[f])));
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}

package/dist/filter.js

@@ -33,7 +33,7 @@ export function parseFilterScalar(raw) {
  * many2one fields only accept numeric ids — a non-numeric value is a usage
  * error pointing at the resolution flags, never a silently empty result.
  */
-export function buildFilterClauses(filters, fields, resolutionHints) {
+export function buildFilterClauses(filters, fields, resolutionHints, unknownFieldHint) {
     const clauses = [];
     for (const filter of filters) {
         const eq = filter.indexOf("=");
@@ -44,7 +44,8 @@ export function buildFilterClauses(filters, fields, resolutionHints) {
         const rawValue = filter.slice(eq + 1);
         const meta = fields.get(field);
         if (!meta) {
-            throw usageError(`unknown field ${JSON.stringify(field)} in --filter`, "check the field name with `odoo crm leads show <id> --all-fields`");
+            throw usageError(`unknown field ${JSON.stringify(field)} in --filter`, unknownFieldHint ??
+                "check the field name with `odoo crm leads show <id> --all-fields`");
         }
         const value = parseFilterScalar(rawValue);
         if (meta.type === "many2one" &&

package/package.json

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