@bergetai/odoo-cli 0.13.1 → 0.15.1

package/README.md

@@ -97,6 +97,12 @@ odoo attachments download 31337 --out ./spec.pdf
 odoo attachments delete 31337 --dry-run
 odoo attachments delete 31337
 
+# Calendar (calendar.event) — read-only
+odoo calendar events list --from 2026-11-04 --to 2026-11-14
+odoo calendar events list --from 2026-11-04 --to 2026-11-14 --assignee erik@berget.ai
+odoo calendar events list --search "Elajo" --json
+odoo calendar events show 27183
+
 # Expenses (hr.expense) — receipts attached as ir.attachment
 odoo expenses list --json
 odoo expenses show 137
@@ -107,6 +113,8 @@ 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
+odoo expenses report create --name "Utlägg sept 2026" --expense 137 --expense 138 --submit --dry-run
+odoo expenses report create --name "Utlägg sept 2026" --expense 137 --expense 138 --submit
 
 # Marketing (mailing.*) — email is the key; trace deletion is always explicit
 odoo marketing lists list
@@ -119,6 +127,13 @@ odoo marketing traces list --email person@example.com --json
 odoo marketing traces delete 7001 --dry-run
 odoo marketing traces delete 7001
 
+# Marketing preview — render a mailing's HTML the way it is sent (read-only)
+odoo marketing preview 145                                    # one-shot temp file, opens the browser
+odoo marketing preview --search "Berget Code"                 # resolve by name/subject
+odoo marketing preview --search code --serve --port 4173      # live-reload server (127.0.0.1 only)
+odoo marketing preview --file template.html                   # local body_arch file (repeatable; '-' = stdin)
+odoo marketing preview --file a.html --file b.html --serve    # switcher with watch & live reload on file saves
+
 # Sign-in identities (res.users) — show + guarded delete only
 odoo users show 9
 odoo users delete 9 --dry-run
@@ -197,6 +212,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)
+- Marketing preview (`marketing preview`) — render a mailing's HTML in a browser the way it is sent: one-shot self-contained temp file (default, opened in the browser) or `--serve` live-reload server bound to 127.0.0.1 that re-fetches the mailings on every browser reload (edits made in the Odoo email editor appear live). Each mailing gets a "Draft" view (body_arch with the send-time base CSS extracted from a sent body_html — white card, Inter, #212529, 720px wrapper) and, when `state=done`, an "As sent" view of the final rendered body_html. `<id>` or `--search` (name/subject ilike), `--limit` for the switcher, `--port`, `--no-open`, or `--file <path>` (repeatable, `-` = stdin) to preview local body_arch-format HTML files instead of server records — files are read verbatim, and preview-only adjustments (shim, instance-absolute URLs) are injected at render time, never written back; with `--serve` file saves auto-reload the browser; `--json` emits `{mode, path|url, mailings|files}`
 - 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`

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { Command, CommanderError } from "commander";
 import { authLoginCommand, authStatusCommand } from "./commands/auth.js";
 import { leadsCreateCommand, leadsDeleteCommand, leadsListCommand, leadsShowCommand, leadsUpdateCommand, crmLeads, } from "./commands/crm.js";
@@ -12,17 +13,20 @@ 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 { expensesAttachCommand, expensesCategoriesCommand, expensesCreateCommand, expensesDeleteCommand, expensesListCommand, expensesReportCreateCommand, 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 { contactsDeleteCommand, contactsListCommand, contactsShowCommand, listsListCommand, listsShowCommand, previewCommand, tracesDeleteCommand, tracesListCommand, tracesShowCommand, } from "./commands/marketing.js";
 import { modelsFieldsCommand, modelsReadCommand, modelsSearchCommand, } from "./commands/models.js";
+import { eventsListCommand, eventsShowCommand, } from "./commands/calendar.js";
 import { footprintCommand, } from "./commands/footprint.js";
 import { CliError } from "./errors.js";
 import { applyGlobalOptions, enforceTransportSecurity, DEFAULT_TIMEOUT, } from "./global-options.js";
 import { printError } from "./output.js";
-const CLI_VERSION = "0.1.0";
+// Read the CLI version from package.json so --version never drifts from the
+// published version (previously hardcoded and forgotten at release time).
+const CLI_VERSION = createRequire(import.meta.url)("../package.json").version;
 /** commander value parser for repeatable options (accumulates values). */
 function collect(value, previous) {
     return [...previous, value];
@@ -766,6 +770,45 @@ Examples:
         .action(async (ids) => {
         await run((g) => usersDeleteCommand(ids, g), program);
     });
+    const calendar = program
+        .command("calendar")
+        .description("Calendar app (calendar.event)");
+    const events = calendar.command("events").description("calendar events");
+    events
+        .command("list")
+        .description("list events overlapping a time window (calendar.event, read-only)")
+        .option("--from <datetime>", "events ending after this time (YYYY-MM-DD [HH:MM])")
+        .option("--to <datetime>", "events starting before this time (YYYY-MM-DD [HH:MM])")
+        .option("--search <text>", "ilike search on the event subject")
+        .option("--assignee <name|id>", "filter by responsible user (login, email, or name)")
+        .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. "start asc"', "start asc")
+        .addHelpText("after", `
+--from/--to select events OVERLAPPING the window: an event matches when it
+starts before --to and stops after --from. Times are server-local (UTC in
+Odoo's storage) — the Odoo calendar usually does not mirror the full Google
+Calendar, so treat results as partial.
+
+Examples:
+  $ odoo calendar events list --from 2026-11-04 --to 2026-11-14
+  $ odoo calendar events list --from 2026-11-04 --to 2026-11-14 --assignee erik@berget.ai
+  $ odoo calendar events list --search "Elajo" --json`)
+        .action(async (opts) => {
+        await run((g) => eventsListCommand(opts, g), program);
+    });
+    events
+        .command("show")
+        .description("read one event")
+        .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) => eventsShowCommand(id, opts, g), program);
+    });
     const attachments = program
         .command("attachments")
         .description("record attachments (ir.attachment)");
@@ -886,6 +929,29 @@ Examples:
         .action(async (opts) => {
         await run((g) => expensesCreateCommand(opts, g), program);
     });
+    const expensesReport = expenses
+        .command("report")
+        .description("expense reports (hr.expense.sheet) — collect and submit");
+    expensesReport
+        .command("create")
+        .description("create an expense report from draft expenses; add --submit to send it for approval")
+        .requiredOption("--name <text>", "report name, e.g. 'Utlägg september 2026'")
+        .requiredOption("--expense <id>", "expense id to include (draft, not yet reported); repeatable", collect, [])
+        .option("--submit", "submit the report for approval immediately (state: Submitted)", false)
+        .option("--employee <name|id>", "report owner (default: employee linked to the authenticated user)")
+        .addHelpText("after", `
+Creates an hr.expense.sheet and links the given expenses to it (same as
+"Create Report" in the web UI). Approval (action_approve_sheet) is NOT
+supported — that step belongs to the approver in the Odoo UI.
+
+Examples:
+  $ odoo expenses report create --name "Utlägg sept 2026" \\
+      --expense 138 --expense 139 --dry-run
+  $ odoo expenses report create --name "Utlägg sept 2026" \\
+      --expense 138 --expense 139 --submit --json`)
+        .action(async (opts) => {
+        await run((g) => expensesReportCreateCommand(opts, g), program);
+    });
     expenses
         .command("attach")
         .description("attach a receipt file to an existing expense")
@@ -1389,6 +1455,37 @@ Examples:
         .action(async (id, opts) => {
         await run((g) => tracesShowCommand(id, opts, g), program);
     });
+    const mlPreview = marketing
+        .command("preview")
+        .description("render a mailing's HTML in a browser the way it is sent (read-only)")
+        .addHelpText("after", `
+The one-shot mode writes a self-contained temp file: each mailing gets a
+"Draft" view (body_arch with the send-time base CSS the editor normally
+provides) and, for sent mailings, an "As sent" view of the final body_html.
+--serve instead runs a local-only server that re-fetches the mailings on every
+browser reload, so edits made in the Odoo email editor appear live.
+
+--file previews local HTML files instead of server records. Files must hold
+the mailing HTML exactly as Odoo stores it in mailing.mailing.body_arch (an
+o_layout fragment); the shim and instance-absolute URLs are injected at
+preview time and never written back to the file. With --serve, saved file
+edits reload the browser automatically. "-" reads from stdin.
+
+Examples:
+  $ odoo marketing preview 145
+  $ odoo marketing preview --search "Berget Code"
+  $ odoo marketing preview --search Berget --serve --port 4173
+  $ odoo marketing preview --file template.html --serve`)
+        .argument("[id]", "mailing.mailing record id")
+        .option("--search <text>", "ilike match on name OR subject")
+        .option("--file <path>", "preview a local body_arch-format HTML file (repeatable; '-' reads stdin)", (value, collect) => [...collect, value], [])
+        .option("--limit <n>", "max mailings to include in the switcher (default: 5)", "5")
+        .option("--serve", "run a local live-reload server instead of a one-shot temp file")
+        .option("--port <n>", "server port (default: 4173; 0 picks a free one)")
+        .option("--no-open", "do not launch the browser")
+        .action(async (id, opts) => {
+        await run((g) => previewCommand(id, opts, g), program);
+    });
     mlTraces
         .command("delete")
         .description("delete send traces explicitly (preview with --dry-run; unknown ids are skipped)")

package/dist/commands/calendar.js

@@ -0,0 +1,67 @@
+import { usageError } from "../errors.js";
+import { listCommand, showCommand, } from "../resource.js";
+/**
+ * Validate a YYYY-MM-DD or "YYYY-MM-DD HH:MM" date string and return it in
+ * the "YYYY-MM-DD HH:MM:SS" format Odoo expects (server stores UTC).
+ */
+function parseDateTime(raw, flagName) {
+    const m = /^(\d{4}-\d{2}-\d{2})(?:[T ](\d{2}:\d{2})(?::\d{2})?)?$/.exec(raw);
+    if (!m) {
+        throw usageError(`invalid ${flagName} ${JSON.stringify(raw)}`, 'expected "YYYY-MM-DD" or "YYYY-MM-DD HH:MM"');
+    }
+    return `${m[1]} ${m[2] ?? "00:00"}:00`;
+}
+export const calendarEvents = {
+    model: "calendar.event",
+    showCommand: "odoo calendar events show",
+    defaultListFields: [
+        "id",
+        "name",
+        "start",
+        "stop",
+        "allday",
+        "user_id",
+        "partner_ids",
+    ],
+    showExtraFields: [
+        "duration",
+        "location",
+        "videocall_location",
+        "description",
+        "privacy",
+        "write_date",
+    ],
+    resolutionHints: {
+        user_id: "--assignee",
+    },
+    priorityLabels: {},
+    pinnedDomain: [],
+    references: {
+        assignee: {
+            model: "res.users",
+            label: "user",
+            field: "user_id",
+            searchFields: ["login", "email", "name"],
+        },
+    },
+    // --from/--to select events OVERLAPPING the window (not just starting in
+    // it): an event matches when it starts before the window ends and stops
+    // after the window begins.
+    extraFilters: (opts) => {
+        const o = opts;
+        const domain = [];
+        if (o.from)
+            domain.push(["stop", ">=", parseDateTime(o.from, "--from")]);
+        if (o.to)
+            domain.push(["start", "<=", parseDateTime(o.to, "--to")]);
+        if (o.search)
+            domain.push(["name", "ilike", o.search]);
+        return Promise.resolve(domain);
+    },
+};
+export function eventsListCommand(opts, globals) {
+    return listCommand(calendarEvents, opts, globals);
+}
+export function eventsShowCommand(idArg, opts, globals) {
+    return showCommand(calendarEvents, idArg, opts, globals);
+}

package/dist/commands/expenses.js

@@ -222,6 +222,75 @@ export async function expensesCreateCommand(opts, globals) {
     const line = `Created hr.expense ${id} (${opts.name})${attSuffix}`;
     process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
 }
+export async function expensesReportCreateCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    const ids = opts.expense.map(parseId);
+    if (ids.length === 0) {
+        throw usageError("pass at least one --expense <id>");
+    }
+    const rows = (await client.executeKw("hr.expense", "read", [ids], {
+        fields: ["id", "name", "state", "sheet_id", "employee_id", "total_amount", "currency_id"],
+    }));
+    if (rows.length !== ids.length) {
+        const found = new Set(rows.map((r) => r.id));
+        const missing = ids.filter((id) => !found.has(id));
+        throw notFoundError("record_not_found", `no hr.expense record(s) with id(s): ${missing.join(", ")}`, "expenses are only visible to their owner unless you are an Expense Manager");
+    }
+    const reported = rows.filter((r) => r.sheet_id !== false);
+    if (reported.length > 0) {
+        throw usageError(`expense(s) already on a report: ${reported.map((r) => `${r.id} (${r.name})`).join(", ")}`);
+    }
+    const employeeId = opts.employee !== undefined
+        ? (await resolveReference(client, "hr.employee", opts.employee, {
+            label: "employee",
+        })).id
+        : await currentEmployee(client);
+    const values = {
+        name: opts.name,
+        employee_id: employeeId,
+        expense_line_ids: [[6, 0, ids]],
+    };
+    if (globals.dryRun) {
+        const preview = { ...values, submit: opts.submit === true };
+        if (globals.json) {
+            printJson({ model: "hr.expense.sheet", action: "create", dry_run: true, values: preview });
+            return;
+        }
+        process.stdout.write(`Would create hr.expense.sheet:\n` +
+            Object.entries(preview)
+                .map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`)
+                .join("\n") +
+            "\n");
+        return;
+    }
+    const id = (await client.executeKw("hr.expense.sheet", "create", [values]));
+    let state = "draft";
+    if (opts.submit === true) {
+        await client.executeKw("hr.expense.sheet", "action_submit_sheet", [[id]]);
+        state = "submit";
+    }
+    const [created] = (await client.executeKw("hr.expense.sheet", "read", [[id]], {
+        fields: ["total_amount", "currency_id"],
+    }));
+    if (globals.json) {
+        printJson({
+            model: "hr.expense.sheet",
+            action: "create",
+            dry_run: false,
+            id,
+            name: opts.name,
+            expense_ids: ids,
+            state,
+            total_amount: created.total_amount,
+            currency: created.currency_id?.[1],
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = `Created hr.expense.sheet ${id} (${opts.name}) with ${ids.length} expense(s)` +
+        (opts.submit === true ? " — submitted" : "");
+    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);

package/dist/commands/marketing.js

@@ -1,4 +1,10 @@
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { watch } from "node:fs";
 import { ModelFields, resolveReference } from "../model.js";
+import { resolveConfig } from "../config.js";
+import { buildPageFromViews, openInBrowser, startPreviewServer, viewFromFile, viewsFromMailings, } from "../preview.js";
 import { authenticatedClient, showCommand, } from "../resource.js";
 import { deleteCommand } from "../mutation.js";
 import { usageError } from "../errors.js";
@@ -182,3 +188,215 @@ export function tracesShowCommand(idArg, opts, globals) {
 export function tracesDeleteCommand(idArgs, globals) {
     return deleteCommand(mailingTrace, idArgs, globals);
 }
+const PREVIEW_FIELDS = ["name", "subject", "state", "body_arch", "body_html"];
+function parsePort(raw) {
+    if (raw === undefined)
+        return 4173;
+    if (!/^\d+$/.test(raw)) {
+        throw usageError(`invalid --port value ${JSON.stringify(raw)}`, "expected a TCP port number (0 picks a random free port)");
+    }
+    const port = Number(raw);
+    if (port > 65535) {
+        throw usageError(`invalid --port value ${JSON.stringify(raw)}`, "port > 65535");
+    }
+    return port;
+}
+async function fetchMailings(client, idArg, opts) {
+    const limitRaw = opts.limit;
+    if (!/^\d+$/.test(limitRaw) || Number(limitRaw) < 1) {
+        throw usageError(`invalid --limit value ${JSON.stringify(limitRaw)}`, "expected a positive integer");
+    }
+    const limit = Number(limitRaw);
+    const domain = [];
+    if (idArg !== undefined) {
+        if (!/^\d+$/.test(idArg)) {
+            throw usageError(`invalid mailing id ${JSON.stringify(idArg)}`, "ids are positive integers \u2014 pass --search <text> to find one by subject");
+        }
+        domain.push(["id", "=", Number(idArg)]);
+    }
+    else if (opts.search) {
+        domain.push("|", ["name", "ilike", opts.search], ["subject", "ilike", opts.search]);
+    }
+    const rows = (await client.executeKw("mailing.mailing", "search_read", [domain], { fields: PREVIEW_FIELDS, limit, order: "id desc" }));
+    if (rows.length === 0) {
+        throw usageError(idArg !== undefined
+            ? `no mailing with id ${idArg}`
+            : `no mailing matching ${JSON.stringify(opts.search)}`, "run `odoo models read mailing.mailing --search <text> --json` to browse");
+    }
+    return rows.map((row) => ({
+        id: row.id,
+        name: row.name ?? "",
+        subject: row.subject ?? "",
+        state: row.state ?? "",
+        body_arch: row.body_arch,
+        body_html: row.body_html,
+    }));
+}
+async function readStdinHtml() {
+    if (process.stdin.isTTY) {
+        throw usageError("--file - requires HTML on stdin", "pipe the mailing HTML, e.g. `cat template.html | odoo marketing preview --file -`");
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    const html = Buffer.concat(chunks).toString("utf8");
+    if (html.trim() === "") {
+        throw usageError("stdin HTML is empty", "pipe a mailing fragment or use --file <path>");
+    }
+    return html;
+}
+async function fetchFileViews(files, baseUrl) {
+    const stdinSlots = files.filter((f) => f === "-").length;
+    if (stdinSlots > 1) {
+        throw usageError("--file - appears more than once", "stdin can feed a single view");
+    }
+    const views = [];
+    for (const f of files) {
+        if (f === "-") {
+            views.push(viewFromFile("stdin.html", await readStdinHtml(), baseUrl));
+            continue;
+        }
+        let content;
+        try {
+            content = await readFile(f, "utf8");
+        }
+        catch (cause) {
+            const code = cause.code;
+            throw usageError(`could not read ${f}${code ? ` (${code})` : ""}`, "the file must hold the mailing HTML exactly as Odoo stores it in mailing.mailing.body_arch");
+        }
+        if (content.trim() === "") {
+            throw usageError(`${f} is empty`, "the file must hold the mailing HTML (body_arch format)");
+        }
+        views.push(viewFromFile(basename(f), content, baseUrl));
+    }
+    return views;
+}
+/** Watch the (--file) drafts and call onChange after writes settle. Returns a disposer. */
+function watchFiles(files, onChange) {
+    const dirs = new Map();
+    for (const f of files) {
+        if (f === "-")
+            continue;
+        const abs = resolve(f);
+        const dir = dirname(abs);
+        const names = dirs.get(dir) ?? new Set();
+        names.add(basename(abs));
+        dirs.set(dir, names);
+    }
+    let timer;
+    const bump = () => {
+        clearTimeout(timer);
+        timer = setTimeout(onChange, 150);
+    };
+    const watchers = [];
+    for (const [dir, names] of dirs) {
+        try {
+            const watcher = watch(dir, (_event, filename) => {
+                if (filename && names.has(filename))
+                    bump();
+            });
+            watcher.on("error", () => { }); // directory vanished; reload still works manually
+            watchers.push(watcher);
+        }
+        catch {
+            // watch() failed (unsupported platform / missing dir); reload still works manually
+        }
+    }
+    return () => {
+        clearTimeout(timer);
+        for (const watcher of watchers)
+            watcher.close();
+    };
+}
+/**
+ * `odoo marketing preview <id> [--search <text>] [--file <path...>]`: render
+ * mailing HTML in a browser the way it is sent. One-shot by default
+ * (self-contained temp file, opened in the browser); --serve runs a local-only
+ * live-reload server. Server records are fetched fresh on every reload; local
+ * files are watched and injected at render time (the file itself is never
+ * modified). Read-only against the server.
+ */
+export async function previewCommand(idArg, opts, globals) {
+    const fileMode = (opts.file?.length ?? 0) > 0;
+    if (!fileMode && idArg === undefined && !opts.search) {
+        throw usageError("nothing to preview", "pass mailing id(s): `odoo marketing preview 145`, --search <text>, or --file <path>");
+    }
+    if (fileMode && (idArg !== undefined || opts.search)) {
+        throw usageError("--file is exclusive with <id> and --search", "--file previews local HTML; <id>/--search preview server mailing.mailing records");
+    }
+    if (idArg !== undefined && opts.search) {
+        throw usageError("<id> and --search are mutually exclusive", "pass either a mailing id or --search");
+    }
+    // Editor-relative URLs (e.g. /web/image/...) are rewritten against the
+    // instance at render time so views resolve outside the Odoo origin
+    // (file://, 127.0.0.1). Source content is never rewritten.
+    const resolved = await resolveConfig({
+        profile: globals.profile,
+        url: globals.url,
+        db: globals.db,
+        username: globals.username,
+        apiKeyFile: globals.apiKeyFile,
+    });
+    const baseUrl = resolved.url;
+    let computeViews;
+    let summary;
+    if (fileMode) {
+        const files = opts.file;
+        summary = { files };
+        computeViews = () => fetchFileViews(files, baseUrl);
+    }
+    else {
+        const client = await authenticatedClient(globals);
+        const mailings = await fetchMailings(client, idArg, opts);
+        summary = {
+            mailings: mailings.map((m) => ({
+                id: m.id,
+                name: m.name,
+                subject: m.subject,
+                state: m.state,
+                views: m.body_html ? ["draft", "as-sent"] : ["draft"],
+            })),
+        };
+        computeViews = async () => viewsFromMailings(mailings, baseUrl);
+    }
+    if (opts.serve) {
+        const initial = await computeViews();
+        const server = await startPreviewServer(computeViews, parsePort(opts.port));
+        const disposeWatcher = fileMode
+            ? watchFiles(opts.file, () => server.notifyChange())
+            : undefined;
+        const openTarget = `${server.url}/#${encodeURIComponent(initial[0].key)}`;
+        if (!opts.noOpen && !globals.json)
+            openInBrowser(openTarget);
+        if (globals.json) {
+            printJson({ mode: "serve", url: server.url, ...summary });
+        }
+        else {
+            process.stdout.write(`Preview server \u2192 ${server.url} (Ctrl-C to stop)\n`);
+        }
+        // Stay up until interrupted; close() makes the promise settle in tests.
+        return new Promise((resolve) => {
+            const stop = () => {
+                process.removeListener("SIGINT", stop);
+                process.removeListener("SIGTERM", stop);
+                disposeWatcher?.();
+                void server.close().then(resolve);
+            };
+            process.once("SIGINT", stop);
+            process.once("SIGTERM", stop);
+        });
+    }
+    const views = await computeViews();
+    const html = buildPageFromViews(views);
+    const dir = await mkdtemp(join(tmpdir(), "odoo-preview-"));
+    const path = join(dir, "preview.html");
+    await writeFile(path, html, "utf8");
+    if (!opts.noOpen && !globals.json)
+        openInBrowser(path);
+    if (globals.json) {
+        printJson({ mode: "file", path, ...summary });
+    }
+    else {
+        process.stdout.write(`Preview written to ${path}\n`);
+    }
+}

package/dist/preview.js

@@ -0,0 +1,231 @@
+import http from "node:http";
+import { spawn } from "node:child_process";
+/**
+ * `marketing preview` support: renders mailing.mailing body_arch/body_html
+ * in a browser the way they are sent.
+ *
+ * Odoo inlines layout CSS into body_html at send time, but body_arch (the
+ * editable source) relies on classes the editor provides. The shim below is
+ * cribbed from prod sent body_html (mailings 51/111 on berget prod): the
+ * o_layout renders as a white card (#fff on #212529 text, Inter, 14px/1.5),
+ * 720px centered wrapper — NOT the editor's tinted theme.
+ */
+export const PREVIEW_SHIM_CSS = `
+  body { margin: 0; }
+  div.o_layout { background-color: #ffffff !important; color: #212529;
+    font-family: Inter, 'Odoo Unicode Support Noto', Arial, sans-serif;
+    font-size: 14px; line-height: 1.5; }
+  .o_mail_wrapper { max-width: 720px; margin: 0 auto; }
+  h1 { font-size: 24px; } h2 { font-size: 20px; }
+  p { margin: 0 0 10px; } ul { margin: 0 0 10px; padding-left: 24px; }
+  img.mw-100, img.img-fluid { max-width: 100%; height: auto; display: block; }
+  img.mx-auto { margin: 0 auto; }
+  .row { display: flex; flex-wrap: wrap; }
+  [class*="col-lg"] { width: 100%; }
+  a { color: currentColor; }
+  .btn { display: inline-block; padding: .5rem 1.25rem; text-decoration: none; }
+  .bg-white { background-color: #fff; }
+  /* Odoo turns pt*/pb* classes into td padding at send; mirror that here so the
+     preview shows the same vertical rhythm as the inbox. */
+  .pt0 { padding-top: 0; } .pt8 { padding-top: 8px; }
+  .pt16 { padding-top: 16px; } .pt24 { padding-top: 24px; }
+  .pt32 { padding-top: 32px; }
+  .pb0 { padding-bottom: 0; } .pb8 { padding-bottom: 8px; }
+  .pb16 { padding-bottom: 16px; } .pb24 { padding-bottom: 24px; }
+  /* Every snippet td gets 15px side padding at send. */
+  .o_mail_snippet_general { padding-left: 15px; padding-right: 15px; }
+`;
+function escapeHtml(raw) {
+    return raw
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+/**
+ * Rewrite Odoo-relative URLs (src, href, data-original-src) against the
+ * instance base URL: body_arch stores /web/image/... and /unsubscribe_from_list
+ * relative — correct in the editor, broken in a file:// temp page or the
+ * local preview server. Already-absolute and scheme-relative URLs untouched.
+ */
+export function absolutizeUrls(html, baseUrl) {
+    const origin = new URL(baseUrl).origin;
+    return html.replaceAll(/((?:src|href|data-original-src)=")\/(?!\/)/g, `$1${origin}/`);
+}
+/** Full document for a body_arch fragment: shim + Google Inter, self-contained. */
+export function wrapFragment(bodyArch, title, baseUrl) {
+    const body = baseUrl ? absolutizeUrls(bodyArch, baseUrl) : bodyArch;
+    return `<!doctype html>
+<html><head><meta charset="utf-8"><title>${escapeHtml(title)}</title>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
+<style>${PREVIEW_SHIM_CSS}</style></head>
+<body>${body}</body></html>`;
+}
+/** Bare document for a sent body_html (already carries inline send CSS). */
+export function wrapSent(bodyHtml, title, baseUrl) {
+    const body = baseUrl ? absolutizeUrls(bodyHtml, baseUrl) : bodyHtml;
+    return `<!doctype html>
+<html><head><meta charset="utf-8"><title>${escapeHtml(title)}</title>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
+</head><body>${body}</body></html>`;
+}
+/** One "Draft (shimmed)" view per mailing plus "As sent" when body_html exists. */
+export function viewsFromMailings(mailings, baseUrl) {
+    return buildViews(mailings, baseUrl);
+}
+function buildViews(mailings, baseUrl) {
+    const views = [];
+    for (const m of mailings) {
+        views.push({
+            key: `${m.id}-draft`,
+            label: `#${m.id} ${m.name || m.subject} — draft`,
+            doc: wrapFragment(m.body_arch ?? "", m.name || `mailing #${m.id}`, baseUrl),
+        });
+        if (m.body_html) {
+            views.push({
+                key: `${m.id}-sent`,
+                label: `#${m.id} ${m.name || m.subject} — as sent`,
+                doc: wrapSent(m.body_html, m.name || `mailing #${m.id}`, baseUrl),
+            });
+        }
+    }
+    return views;
+}
+/**
+ * A preview view for a local HTML file holding Odoo mailing content exactly as
+ * the Email Marketing editor would store it in `body_arch` (an `o_layout`
+ * fragment). The file itself is never modified: the shim and any URL
+ * absolutization are injected at preview-render time only.
+ */
+export function viewFromFile(fileName, html, baseUrl) {
+    return {
+        key: `${fileName}-draft`,
+        label: `${fileName} — draft`,
+        doc: wrapFragment(html, fileName, baseUrl),
+    };
+}
+/** Embed JSON in a <script> safely: break </script> and <script> sequences. */
+function embedJson(value) {
+    return JSON.stringify(value)
+        .replaceAll("<", "\\u003c")
+        .replaceAll(">", "\\u003e")
+        .replaceAll("&", "\\u0026");
+}
+const VIEWER_PAGE = String.raw `
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Mailing preview</title>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
+<style>
+  body { margin: 0; background: #eef0f2; font-family: Inter, Arial, sans-serif; color: #212529; }
+  header { display: flex; gap: 12px; align-items: center; padding: 8px 16px; background: #fff; border-bottom: 1px solid #d8dbdd; position: sticky; top: 0; z-index: 1; }
+  select { font: inherit; padding: 4px 8px; max-width: 60vw; }
+  .status { margin-left: auto; font-size: 12px; color: #6c757d; }
+  main { padding: 24px 16px 48px; display: flex; justify-content: center; }
+  iframe { width: 720px; min-height: 90vh; background: #fff; border: none; box-shadow: 0 1px 4px rgba(0,0,0,.15); }
+</style></head>
+<body>
+<header>
+  <label>Mailing <select id="view"></select></label>
+  <span class="status" id="status"></span>
+</header>
+<main><iframe id="frame" title="mailing preview"></iframe></main>
+<script id="views-data" type="application/json">[]</script>
+<script>
+const views = JSON.parse(document.getElementById("views-data").textContent);
+const sel = document.getElementById("view");
+const frame = document.getElementById("frame");
+const status = document.getElementById("status");
+for (const v of views) {
+  const o = document.createElement("option");
+  o.value = v.key; o.textContent = v.label;
+  sel.append(o);
+}
+function show() {
+  const key = location.hash ? decodeURIComponent(location.hash.slice(1)) : sel.value;
+  const v = views.find(x => x.key === key);
+  if (!v) return;
+  sel.value = v.key;
+  frame.srcdoc = v.doc;
+  location.hash = v.key;
+  status.textContent = v.label;
+}
+sel.onchange = show;
+show();
+new EventSource("/events").onmessage = () => location.reload();
+</script>
+</body></html>
+`;
+/** Self-contained viewer page for a ready set of views. */
+export function buildPageFromViews(views) {
+    const placeholder = '<script id="views-data" type="application/json">[]<\/script>';
+    return VIEWER_PAGE.replace(placeholder, `<${"script"} id="views-data" type="application/json">${embedJson(views)}</${"script"}>`).trimStart();
+}
+/** Compatibility wrapper: viewer page over mailing records. */
+export function buildPreviewHtml(mailings, baseUrl) {
+    return buildPageFromViews(buildViews(mailings, baseUrl));
+}
+export function startPreviewServer(refetch, port) {
+    const clients = new Set();
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        if (url.pathname === "/events") {
+            res.writeHead(200, {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache",
+                connection: "keep-alive",
+            });
+            res.write("data: hello\n\n");
+            clients.add(res);
+            req.on("close", () => clients.delete(res));
+            return;
+        }
+        if (url.pathname !== "/") {
+            res.writeHead(404).end("not found");
+            return;
+        }
+        try {
+            const views = await refetch();
+            // Content changed server-side → nudge open pages to reload.
+            for (const client of clients)
+                client.write("data: reload\n\n");
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end(buildPageFromViews(views));
+        }
+        catch (cause) {
+            res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+            res.end(`preview refetch failed: ${cause.message}`);
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", () => {
+            const address = server.address();
+            resolve({
+                url: `http://127.0.0.1:${address.port}`,
+                notifyChange: () => {
+                    for (const client of clients)
+                        client.write("data: reload\n\n");
+                },
+                close: () => new Promise((done) => {
+                    for (const client of clients)
+                        client.end();
+                    clients.clear();
+                    server.close(() => done());
+                }),
+            });
+        });
+    });
+}
+/** Open a file or URL with the platform opener; never throws on failure. */
+export function openInBrowser(target) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", target] : [target];
+    try {
+        spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+    }
+    catch {
+        // headless environments: the caller's human output includes the path/URL
+    }
+}

package/package.json

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