@bergetai/odoo-cli 0.3.2 → 0.4.1

package/README.md

@@ -40,6 +40,13 @@ odoo crm leads create --name "New lead" --email info@example.com
 odoo crm leads update 42 --stage Won
 odoo crm leads delete 42 --yes
 
+# Sales teams (crm.team)
+odoo crm teams list
+odoo crm teams show 5
+odoo crm teams create --name "Partnerships" --team-leader alice@acme.com
+odoo crm teams update 5 --name "Direct Sales (renamed)" --dry-run
+odoo crm teams delete 5 --dry-run
+
 # Internal notes (NEVER sends email to customer)
 odoo helpdesk tickets add-note 398 --body "Internal note text"
 odoo helpdesk tickets add-note 398 --body-file note.md
@@ -52,6 +59,7 @@ Note: `odoo --version` prints the CLI's own version; `odoo version` queries the
 ## Features
 
 - Read-only CRM surface (`crm leads list/show`) — default columns, `--fields`/`--all-fields`, `--limit`/`--offset`/`--order`, `--domain`/`--filter` with `fields_get` type checking, reference resolution (`--stage`/`--team`/`--assignee`/`--tag`), table/JSON output with `search_count` envelope
+- Sales teams surface (`crm teams list/show/create/update/delete`) — `--archived` (include inactive teams), `--team-leader` (team leader, login/email/name), `--active`/`--use-leads`/`--use-opportunities`/`--invoiced-target`/`--color`/`--sequence`, full `--dry-run` support, `--fields`/`--all-fields`, table/JSON output
 - 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)

package/dist/cli.js

@@ -2,8 +2,10 @@
 import { Command, CommanderError } from "commander";
 import { authLoginCommand, authStatusCommand } from "./commands/auth.js";
 import { leadsCreateCommand, leadsDeleteCommand, leadsListCommand, leadsShowCommand, leadsUpdateCommand, crmLeads, } from "./commands/crm.js";
+import { teamsCreateCommand, teamsDeleteCommand, teamsListCommand, teamsShowCommand, teamsUpdateCommand, crmTeams, } from "./commands/teams.js";
 import { ticketsCreateCommand, ticketsDeleteCommand, ticketsListCommand, ticketsShowCommand, ticketsUpdateCommand, helpdeskTickets, } from "./commands/helpdesk.js";
 import { addNoteCommand, listMessagesCommand, } from "./commands/notes.js";
+import { activitiesListCommand, activityDoneCommand, scheduleCommand, } from "./commands/activities.js";
 import { createTaskCommand, projectListCommand, projectShowCommand, tasksListCommand, tasksShowCommand, } from "./commands/project.js";
 import { documentsDocuments, documentsListCommand, foldersListCommand, documentsShowCommand, documentsCreateCommand, documentsUpdateCommand, documentsDeleteCommand, treeCommand, uploadCommand, } from "./commands/documents.js";
 import { versionCommand } from "./commands/version.js";
@@ -130,6 +132,142 @@ Examples:
         .action(async (ids) => {
         await run((g) => leadsDeleteCommand(ids, g), program);
     });
+    leads
+        .command("add-note")
+        .description("add an internal Log Note to a lead/opportunity (NEVER sends email)")
+        .argument("<id>", "record id")
+        .option("--body <text>", "note body (HTML allowed)")
+        .option("--body-file <path>", "read note body from file ('-' for stdin)")
+        .addHelpText("after", `
+IMPORTANT: This command creates INTERNAL notes only. These notes:
+  • Are NEVER sent to the customer via email
+  • Are only visible to internal users in Odoo
+  • Use subtype_id=2 (Note) and message_type=comment
+  • Cannot be used for customer-facing communication
+
+This is by design to prevent accidental customer emails.
+
+Examples:
+  $ odoo crm records add-note 338 --body "Internal note text"
+  $ odoo crm records add-note 338 --body-file note.md
+  $ cat note.md | odoo crm records add-note 338 --body-file -`)
+        .action(async (id, opts) => {
+        await run((g) => addNoteCommand(id, opts, g, "crm.lead"), program);
+    });
+    leads
+        .command("messages")
+        .description("list all messages for a record (emails, comments, notes)")
+        .argument("<id>", "record id")
+        .option("--limit <n>", "max messages to fetch", "50")
+        .option("--message-type <type>", "filter by message type (email, comment, notification)")
+        .option("--subtype <id>", "filter by subtype ID")
+        .option("--author <id>", "filter by author ID")
+        .option("--since <date>", "only messages after this date (YYYY-MM-DD HH:MM:SS)")
+        .addHelpText("after", `
+Examples:
+  # List all messages for lead 338
+  $ odoo crm records messages 338
+
+  # List only internal notes
+  $ odoo crm records messages 338 --subtype 2
+
+  # JSON output for scripting
+  $ odoo crm records messages 338 --json`)
+        .action(async (id, opts) => {
+        await run((g) => listMessagesCommand(id, opts, g, "crm.lead"), program);
+    });
+    leads
+        .command("schedule")
+        .description("schedule a new activity on a record (preview with --dry-run)")
+        .argument("<id>", "record id")
+        .requiredOption("--type <name|id>", "activity type (e.g. To-Do, Call, Meeting)")
+        .requiredOption("--deadline <yyyy-mm-dd>", "activity deadline")
+        .requiredOption("--summary <text>", "short summary (max 1 sentence)")
+        .option("--note <text>", "optional note (1-2 lines, point to the log)")
+        .option("--assignee <name|id>", "assignee (login, email, or name; default: you)")
+        .addHelpText("after", `
+A scheduled activity is the source of truth for a record's next step.
+An opportunity without a scheduled activity is a red flag.
+
+Examples:
+  $ odoo crm records schedule 338 --type "To-Do" --deadline 2026-08-25 \\
+      --summary "Send quote to Fredrik"
+  $ odoo crm records schedule 338 --type Meeting --deadline 2026-09-01 \\
+      --summary "Kickoff call" --assignee erik@berget.ai
+  $ odoo crm records schedule 338 --type "To-Do" --deadline 2026-08-25 \\
+      --summary "Send quote" --dry-run`)
+        .action(async (id, opts) => {
+        await run((g) => scheduleCommand(id, opts, g), program);
+    });
+    leads
+        .command("activities")
+        .description("list activities for a record")
+        .argument("<id>", "record id")
+        .option("--open", "only open (pending/planned) activities")
+        .option("--limit <n>", "max activities to fetch", "50")
+        .addHelpText("after", `
+Examples:
+  $ odoo crm records activities 338
+  $ odoo crm records activities 338 --open --json`)
+        .action(async (id, opts) => {
+        await run((g) => activitiesListCommand(id, opts, g), program);
+    });
+    leads
+        .command("activity-done")
+        .description("mark activities as done via action_done (preview with --dry-run)")
+        .argument("<id...>", "activity ids")
+        .addHelpText("after", `
+Uses action_done — the only reliable way to close an activity in Odoo
+(writing state='done' directly does not work).
+
+Examples:
+  $ odoo crm records activity-done 714
+  $ odoo crm records activity-done 714 721 --dry-run`)
+        .action(async (ids) => {
+        await run((g) => activityDoneCommand(ids, g), program);
+    });
+    const teams = crm.command("teams").description("sales teams (crm.team)");
+    teams
+        .command("list")
+        .description("search and list sales teams with curated default columns")
+        .option("--archived", "include archived teams (active = false) instead of active only")
+        .option("--domain <json>", "Odoo domain as a JSON array")
+        .option("--filter <f=v>", "equality filter; repeatable, AND-ed", collect, [])
+        .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. "name asc"', undefined)
+        .action(async (opts) => {
+        await run((g) => teamsListCommand(opts, g), program);
+    });
+    teams
+        .command("show")
+        .description("read one sales team")
+        .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) => teamsShowCommand(id, opts, g), program);
+    });
+    addMutationFlags(teams
+        .command("create")
+        .description("create a sales team (preview with --dry-run)"), crmTeams).action(async (opts) => {
+        await run((g) => teamsCreateCommand(opts, g), program);
+    });
+    addMutationFlags(teams
+        .command("update")
+        .description("update sales teams (preview with --dry-run)"), crmTeams)
+        .argument("<id...>", "record ids")
+        .action(async (ids, opts) => {
+        await run((g) => teamsUpdateCommand(ids, opts, g), program);
+    });
+    teams
+        .command("delete")
+        .description("delete sales teams (preview with --dry-run; unknown ids are skipped)")
+        .argument("<id...>", "record ids")
+        .action(async (ids) => {
+        await run((g) => teamsDeleteCommand(ids, g), program);
+    });
     const helpdesk = program
         .command("helpdesk")
         .description("Helpdesk app (helpdesk.ticket, Enterprise)");
@@ -207,7 +345,7 @@ Examples:
   $ odoo helpdesk tickets add-note 398 --body-file note.md
   $ cat note.md | odoo helpdesk tickets add-note 398 --body-file -`)
         .action(async (id, opts) => {
-        await run((g) => addNoteCommand(id, opts, g), program);
+        await run((g) => addNoteCommand(id, opts, g, "helpdesk.ticket"), program);
     });
     tickets
         .command("messages")
@@ -235,7 +373,7 @@ Examples:
   # JSON output for scripting
   $ odoo helpdesk tickets messages 398 --json`)
         .action(async (id, opts) => {
-        await run((g) => listMessagesCommand(id, opts, g), program);
+        await run((g) => listMessagesCommand(id, opts, g, "helpdesk.ticket"), program);
     });
     const project = program
         .command("project")

package/dist/commands/activities.js

@@ -0,0 +1,239 @@
+import { OdooClient } from "../client.js";
+import { resolveConfig } from "../config.js";
+import { notFoundError, usageError } from "../errors.js";
+import { parseDate } from "../mutation.js";
+import { resolveReference } from "../model.js";
+import { printJson, verbose as logVerbose } from "../output.js";
+import { formatTable } from "../table.js";
+/**
+ * Scheduled activities (mail.activity) for crm.lead records.
+ *
+ * A `mail.activity` is the source of truth for a lead's next step. It carries
+ * a type (To-Do, Call, Meeting, Email, ...), a deadline, an assignee, and a
+ * short note. `action_done` marks it complete (the only reliable way to close
+ * an activity — writing state='done' directly does not work in Odoo).
+ */
+const CRM_LEAD_MODEL = "crm.lead";
+async function buildClient(globals) {
+    const config = await resolveConfig(globals);
+    if (!config.url || !config.db || !config.username || !config.apiKey) {
+        throw usageError("missing configuration", "run 'odoo auth login' or set ODOO_URL, ODOO_DB, ODOO_USERNAME, ODOO_API_KEY");
+    }
+    const { parseDurationMs } = await import("../duration.js");
+    const timeoutMs = parseDurationMs(globals.timeout);
+    return new OdooClient(config.url, config.db, config.username, config.apiKey, { timeoutMs, verbose: globals.verbose });
+}
+/** Resolve the ir.model id for a technical model name (e.g. "crm.lead"). */
+async function resolveResModelId(client, technicalName) {
+    const rows = (await client.executeKw("ir.model", "search_read", [[["model", "=", technicalName]]], { fields: ["id"], limit: 1 }));
+    if (rows.length === 0) {
+        throw notFoundError("model_not_found", `no ir.model for ${JSON.stringify(technicalName)}`);
+    }
+    return rows[0].id;
+}
+/**
+ * Schedule a new activity on a crm.lead record.
+ */
+export async function scheduleCommand(recordId, opts, globals) {
+    const id = Number.parseInt(recordId, 10);
+    if (Number.isNaN(id) || id <= 0) {
+        throw usageError(`invalid lead id: ${recordId}`, "provide a positive integer");
+    }
+    const client = await buildClient(globals);
+    // Verify the lead exists
+    const leads = (await client.executeKw(CRM_LEAD_MODEL, "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
+    if (!leads || leads.length === 0) {
+        throw notFoundError("record_not_found", `crm.lead #${id} does not exist`, "check the lead id");
+    }
+    // Resolve the activity type by name or id
+    const activityType = await resolveReference(client, "mail.activity.type", opts.type, {
+        label: "activity type",
+    });
+    // Resolve the assignee (defaults to the authenticated user)
+    let assigneeId;
+    let assigneeName;
+    if (opts.assignee) {
+        const user = await resolveReference(client, "res.users", opts.assignee, {
+            label: "user",
+            searchFields: ["login", "email", "name"],
+        });
+        assigneeId = user.id;
+        assigneeName = user.name;
+    }
+    else {
+        // The authenticated user's own id is not directly exposed; resolve the
+        // current user via the uid returned by authenticate.
+        const uid = await client.authenticate();
+        const me = (await client.executeKw("res.users", "search_read", [[["id", "=", uid]]], { fields: ["id", "name"], limit: 1 }));
+        assigneeId = me[0]?.id ?? uid;
+        assigneeName = me[0]?.name ?? String(uid);
+    }
+    const resModelId = await resolveResModelId(client, CRM_LEAD_MODEL);
+    const deadline = parseDate(opts.deadline, "--deadline");
+    const values = {
+        res_model_id: resModelId,
+        res_id: id,
+        activity_type_id: activityType.id,
+        user_id: assigneeId,
+        date_deadline: deadline,
+        summary: opts.summary,
+        ...(opts.note ? { note: opts.note } : {}),
+    };
+    if (globals.verbose) {
+        logVerbose(`Scheduling activity on crm.lead #${id} (${leads[0].name})`, globals.verbose);
+        logVerbose(`Activity values: ${JSON.stringify(values, null, 2)}`, globals.verbose);
+    }
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: "mail.activity",
+                action: "create",
+                dry_run: true,
+                record: { model: CRM_LEAD_MODEL, id, name: leads[0].name },
+                values,
+                resolved: {
+                    activity_type_id: [activityType.id, activityType.name],
+                    user_id: [assigneeId, assigneeName],
+                },
+            });
+        }
+        else {
+            console.log(`[DRY RUN] Would schedule activity on crm.lead #${id} — ${leads[0].name}:`);
+            console.log(`  Type: ${activityType.name} (${activityType.id})`);
+            console.log(`  Assignee: ${assigneeName} (${assigneeId})`);
+            console.log(`  Deadline: ${deadline}`);
+            console.log(`  Summary: ${opts.summary}`);
+            if (opts.note)
+                console.log(`  Note: ${opts.note}`);
+        }
+        return;
+    }
+    const activityId = (await client.executeKw("mail.activity", "create", [
+        values,
+    ]));
+    if (globals.json) {
+        printJson({
+            model: "mail.activity",
+            action: "create",
+            dry_run: false,
+            id: activityId,
+            record: { model: CRM_LEAD_MODEL, id, name: leads[0].name },
+            resolved: {
+                activity_type_id: [activityType.id, activityType.name],
+                user_id: [assigneeId, assigneeName],
+            },
+        });
+    }
+    else {
+        console.log(`✓ Activity scheduled (ID: ${activityId})`);
+        console.log(`  Lead: crm.lead #${id} — ${leads[0].name}`);
+        console.log(`  Type: ${activityType.name} · Deadline: ${deadline} · Assignee: ${assigneeName}`);
+    }
+}
+/**
+ * Mark one or more activities as done via `action_done`.
+ */
+export async function activityDoneCommand(activityIds, globals) {
+    const ids = activityIds.map((raw) => {
+        const n = Number.parseInt(raw, 10);
+        if (Number.isNaN(n) || n <= 0) {
+            throw usageError(`invalid activity id: ${raw}`, "provide a positive integer");
+        }
+        return n;
+    });
+    const client = await buildClient(globals);
+    // Verify the activities exist
+    const rows = (await client.executeKw("mail.activity", "search_read", [[["id", "in", ids]]], { fields: ["id", "summary", "state"], limit: ids.length }));
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const missing = ids.filter((id) => !byId.has(id));
+    if (missing.length > 0) {
+        throw notFoundError("record_not_found", `no mail.activity record(s) with id(s): ${missing.join(", ")}`, "no activities were modified — aborts the whole batch when any id is missing");
+    }
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: "mail.activity",
+                action: "action_done",
+                dry_run: true,
+                ids,
+                activities: rows.map((r) => ({ id: r.id, summary: r.summary, state: r.state })),
+            });
+        }
+        else {
+            console.log(`[DRY RUN] Would mark ${ids.length} activity(ies) as done:`);
+            for (const r of rows) {
+                console.log(`  #${r.id} — ${r.summary} (${r.state})`);
+            }
+        }
+        return;
+    }
+    await client.executeKw("mail.activity", "action_done", [ids]);
+    if (globals.json) {
+        printJson({
+            model: "mail.activity",
+            action: "action_done",
+            dry_run: false,
+            done: ids,
+        });
+    }
+    else {
+        console.log(`✓ Marked ${ids.length} activity(ies) as done: ${ids.join(", ")}`);
+    }
+}
+/**
+ * List activities for a crm.lead record.
+ */
+export async function activitiesListCommand(recordId, opts, globals) {
+    const id = Number.parseInt(recordId, 10);
+    if (Number.isNaN(id) || id <= 0) {
+        throw usageError(`invalid lead id: ${recordId}`, "provide a positive integer");
+    }
+    const client = await buildClient(globals);
+    // Verify the lead exists
+    const leads = (await client.executeKw(CRM_LEAD_MODEL, "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
+    if (!leads || leads.length === 0) {
+        throw notFoundError("record_not_found", `crm.lead #${id} does not exist`, "check the lead id");
+    }
+    const resModelId = await resolveResModelId(client, CRM_LEAD_MODEL);
+    const domain = [
+        ["res_model_id", "=", resModelId],
+        ["res_id", "=", id],
+    ];
+    if (opts.open) {
+        domain.push(["state", "in", ["pending", "planned", "a_review"]]);
+    }
+    const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 50;
+    const activities = (await client.executeKw("mail.activity", "search_read", [domain], {
+        fields: [
+            "id",
+            "activity_type_id",
+            "date_deadline",
+            "summary",
+            "note",
+            "state",
+            "user_id",
+        ],
+        limit,
+        order: "date_deadline asc",
+    }));
+    if (globals.json) {
+        printJson({
+            model: "mail.activity",
+            record: { model: CRM_LEAD_MODEL, id, name: leads[0].name },
+            count: activities.length,
+            activities,
+        });
+        return;
+    }
+    console.log(`Activities for crm.lead #${id}: ${leads[0].name}`);
+    console.log(`Found ${activities.length} activities\n`);
+    const rows = activities.map((a) => [
+        a.id.toString(),
+        a.state,
+        a.activity_type_id ? a.activity_type_id[1] : "",
+        a.date_deadline ? String(a.date_deadline) : "",
+        a.user_id ? a.user_id[1] : "",
+        a.summary,
+    ]);
+    console.log(formatTable(["ID", "State", "Type", "Deadline", "Assignee", "Summary"], rows, !globals.noColor));
+}

package/dist/commands/notes.js

@@ -3,12 +3,27 @@ import { resolveConfig } from "../config.js";
 import { notFoundError, usageError } from "../errors.js";
 import { printJson, verbose as logVerbose } from "../output.js";
 import { formatTable } from "../table.js";
-export async function addNoteCommand(ticketId, opts, globals) {
-    const id = Number.parseInt(ticketId, 10);
-    if (Number.isNaN(id) || id <= 0) {
-        throw usageError(`invalid ticket id: ${ticketId}`, "provide a positive integer");
+const THREAD_MODELS = {
+    "helpdesk.ticket": { model: "helpdesk.ticket", label: "ticket" },
+    "crm.lead": { model: "crm.lead", label: "lead" },
+};
+function threadModel(model) {
+    const spec = THREAD_MODELS[model];
+    if (!spec) {
+        throw usageError(`unsupported thread model ${JSON.stringify(model)}`, `expected one of: ${Object.keys(THREAD_MODELS).join(", ")}`);
+    }
+    return spec;
+}
+async function buildClient(globals) {
+    const config = await resolveConfig(globals);
+    if (!config.url || !config.db || !config.username || !config.apiKey) {
+        throw usageError("missing configuration", "run 'odoo auth login' or set ODOO_URL, ODOO_DB, ODOO_USERNAME, ODOO_API_KEY");
     }
-    // Read body from file if specified
+    const { parseDurationMs } = await import("../duration.js");
+    const timeoutMs = parseDurationMs(globals.timeout);
+    return new OdooClient(config.url, config.db, config.username, config.apiKey, { timeoutMs, verbose: globals.verbose });
+}
+async function readBody(opts) {
     let body = opts.body;
     if (opts.bodyFile) {
         const fs = await import("node:fs/promises");
@@ -22,39 +37,45 @@ export async function addNoteCommand(ticketId, opts, globals) {
     if (!body || body.trim().length === 0) {
         throw usageError("note body cannot be empty", "provide --body or --body-file");
     }
-    const config = await resolveConfig(globals);
-    if (!config.url || !config.db || !config.username || !config.apiKey) {
-        throw usageError("missing configuration", "run 'odoo auth login' or set ODOO_URL, ODOO_DB, ODOO_USERNAME, ODOO_API_KEY");
+    return body;
+}
+/**
+ * Add an internal Log Note to a mail-thread record (ticket or lead).
+ */
+export async function addNoteCommand(recordId, opts, globals, model) {
+    const spec = threadModel(model);
+    const id = Number.parseInt(recordId, 10);
+    if (Number.isNaN(id) || id <= 0) {
+        throw usageError(`invalid ${spec.label} id: ${recordId}`, "provide a positive integer");
     }
-    const { parseDurationMs } = await import("../duration.js");
-    const timeoutMs = parseDurationMs(globals.timeout);
-    const client = new OdooClient(config.url, config.db, config.username, config.apiKey, { timeoutMs, verbose: globals.verbose });
-    // Verify ticket exists
-    const tickets = (await client.executeKw("helpdesk.ticket", "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
-    if (!tickets || tickets.length === 0) {
-        throw notFoundError("ticket_not_found", `helpdesk ticket #${id} does not exist`, "check the ticket id");
+    const body = await readBody(opts);
+    const client = await buildClient(globals);
+    // Verify the record exists
+    const rows = (await client.executeKw(spec.model, "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
+    if (!rows || rows.length === 0) {
+        throw notFoundError("record_not_found", `${spec.model} #${id} does not exist`, `check the ${spec.label} id`);
     }
     // Create internal Log Note
     // CRITICAL: These parameters ensure the note is INTERNAL ONLY
     // - subtype_id=2: "Note" subtype (internal, not sent to customer)
     // - message_type="comment": Internal comment (not email)
-    // - author_id: Use the authenticated user's partner_id
     const noteParams = {
-        model: "helpdesk.ticket",
+        model: spec.model,
         res_id: id,
         body: body,
         message_type: "comment",
         subtype_id: 2, // Note subtype = internal only, NEVER sends email
     };
     if (globals.verbose) {
-        logVerbose(`Creating internal note for ticket #${id} (${tickets[0].name})`, globals.verbose);
+        logVerbose(`Creating internal note for ${spec.model} #${id} (${rows[0].name})`, globals.verbose);
         logVerbose(`Note parameters: ${JSON.stringify(noteParams, null, 2)}`, globals.verbose);
     }
     if (globals.dryRun) {
         const result = {
             dry_run: true,
-            ticket_id: id,
-            ticket_name: tickets[0].name,
+            model: spec.model,
+            record_id: id,
+            record_name: rows[0].name,
             note_type: "internal_log_note",
             will_send_email: false,
             body_preview: body.substring(0, 100) + (body.length > 100 ? "..." : ""),
@@ -65,7 +86,7 @@ export async function addNoteCommand(ticketId, opts, globals) {
         }
         else {
             console.log(`[DRY RUN] Would create internal Log Note:`);
-            console.log(`  Ticket: #${id} — ${tickets[0].name}`);
+            console.log(`  Record: ${spec.model} #${id} — ${rows[0].name}`);
             console.log(`  Type: Internal note (never sent to customer)`);
             console.log(`  Body length: ${body.length} characters`);
             console.log(`  Body preview: ${result.body_preview}`);
@@ -77,8 +98,9 @@ export async function addNoteCommand(ticketId, opts, globals) {
     ]));
     const result = {
         note_id: noteId,
-        ticket_id: id,
-        ticket_name: tickets[0].name,
+        model: spec.model,
+        record_id: id,
+        record_name: rows[0].name,
         note_type: "internal_log_note",
         email_sent: false,
     };
@@ -87,37 +109,31 @@ export async function addNoteCommand(ticketId, opts, globals) {
     }
     else {
         console.log(`✓ Internal Log Note created (ID: ${noteId})`);
-        console.log(`  Ticket: #${id} — ${tickets[0].name}`);
+        console.log(`  Record: ${spec.model} #${id} — ${rows[0].name}`);
         console.log(`  Type: Internal note (not sent to customer)`);
     }
 }
 /**
- * List messages for a helpdesk ticket.
+ * List messages for a mail-thread record (emails, comments, notes).
  *
- * Fetches all messages (emails, comments, notes) associated with a ticket.
- * Useful for analyzing ticket history and determining if customer is waiting
- * for a response.
+ * Fetches all messages associated with the record. Useful for analyzing
+ * history and determining if the customer is waiting for a response.
  */
-export async function listMessagesCommand(ticketId, opts, globals) {
-    const id = Number.parseInt(ticketId, 10);
+export async function listMessagesCommand(recordId, opts, globals, model) {
+    const spec = threadModel(model);
+    const id = Number.parseInt(recordId, 10);
     if (Number.isNaN(id) || id <= 0) {
-        throw usageError(`invalid ticket id: ${ticketId}`, "provide a positive integer");
+        throw usageError(`invalid ${spec.label} id: ${recordId}`, "provide a positive integer");
     }
-    const config = await resolveConfig(globals);
-    if (!config.url || !config.db || !config.username || !config.apiKey) {
-        throw usageError("missing configuration", "run 'odoo auth login' or set ODOO_URL, ODOO_DB, ODOO_USERNAME, ODOO_API_KEY");
-    }
-    const { parseDurationMs } = await import("../duration.js");
-    const timeoutMs = parseDurationMs(globals.timeout);
-    const client = new OdooClient(config.url, config.db, config.username, config.apiKey, { timeoutMs, verbose: globals.verbose });
-    // Verify ticket exists
-    const tickets = (await client.executeKw("helpdesk.ticket", "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
-    if (!tickets || tickets.length === 0) {
-        throw notFoundError("ticket_not_found", `helpdesk ticket #${id} does not exist`, "check the ticket id");
+    const client = await buildClient(globals);
+    // Verify the record exists
+    const rows = (await client.executeKw(spec.model, "search_read", [[["id", "=", id]]], { fields: ["id", "name"], limit: 1 }));
+    if (!rows || rows.length === 0) {
+        throw notFoundError("record_not_found", `${spec.model} #${id} does not exist`, `check the ${spec.label} id`);
     }
     // Build domain for messages
     const domain = [
-        ["model", "=", "helpdesk.ticket"],
+        ["model", "=", spec.model],
         ["res_id", "=", id],
     ];
     // Add optional filters
@@ -141,7 +157,7 @@ export async function listMessagesCommand(ticketId, opts, globals) {
     }
     const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 50;
     if (globals.verbose) {
-        logVerbose(`Fetching messages for ticket #${id}`, globals.verbose);
+        logVerbose(`Fetching messages for ${spec.model} #${id}`, globals.verbose);
         logVerbose(`Domain: ${JSON.stringify(domain)}`, globals.verbose);
     }
     const messages = (await client.executeKw("mail.message", "search_read", [domain], {
@@ -160,16 +176,17 @@ export async function listMessagesCommand(ticketId, opts, globals) {
     }));
     if (globals.json) {
         printJson({
-            ticket_id: id,
-            ticket_name: tickets[0].name,
+            model: spec.model,
+            record_id: id,
+            record_name: rows[0].name,
             message_count: messages.length,
             messages,
         });
     }
     else {
-        console.log(`Messages for ticket #${id}: ${tickets[0].name}`);
+        console.log(`Messages for ${spec.model} #${id}: ${rows[0].name}`);
         console.log(`Found ${messages.length} messages\n`);
-        const rows = messages.map((msg) => {
+        const rowsOut = messages.map((msg) => {
             const author = msg.author_id ? msg.author_id[1] : msg.email_from || "System";
             const subtype = msg.subtype_id ? msg.subtype_id[1] : "";
             const bodyPreview = msg.body
@@ -186,6 +203,6 @@ export async function listMessagesCommand(ticketId, opts, globals) {
                 bodyPreview + (msg.body.length > 60 ? "..." : ""),
             ];
         });
-        console.log(formatTable(["ID", "Date", "Type", "Subtype", "Author", "Preview"], rows, !globals.noColor));
+        console.log(formatTable(["ID", "Date", "Type", "Subtype", "Author", "Preview"], rowsOut, !globals.noColor));
     }
 }

package/dist/commands/teams.js

@@ -0,0 +1,199 @@
+import { ModelFields } from "../model.js";
+import { authenticatedClient, showCommand, } from "../resource.js";
+import { createCommand, deleteCommand, parseDecimal, updateCommand, } from "../mutation.js";
+import { buildFilterClauses, parseDomain } from "../filter.js";
+import { usageError } from "../errors.js";
+import { colorEnabled, printJson } from "../output.js";
+import { formatTable, humanCell } from "../table.js";
+function parseBooleanFlag(raw, flagName) {
+    const v = raw.toLowerCase();
+    if (v === "true" || v === "1" || v === "yes")
+        return true;
+    if (v === "false" || v === "0" || v === "no")
+        return false;
+    throw usageError(`invalid ${flagName} value ${JSON.stringify(raw)}`, "expected: true or false");
+}
+const crmTeamsMutation = {
+    flags: [
+        {
+            flags: "--name <name>",
+            option: "name",
+            field: "name",
+            help: "Sales team name",
+            requiredOnCreate: true,
+        },
+        {
+            flags: "--team-leader <name|id>",
+            option: "teamLeader",
+            field: "user_id",
+            help: "Team leader (login, email, or name)",
+            reference: {
+                model: "res.users",
+                label: "user",
+                searchFields: ["login", "email", "name"],
+            },
+        },
+        {
+            flags: "--active <true|false>",
+            option: "active",
+            field: "active",
+            help: "Active flag (default: true on create)",
+            parse: parseBooleanFlag,
+        },
+        {
+            flags: "--use-leads <true|false>",
+            option: "useLeads",
+            field: "use_leads",
+            help: "Enable leads",
+            parse: parseBooleanFlag,
+        },
+        {
+            flags: "--use-opportunities <true|false>",
+            option: "useOpportunities",
+            field: "use_opportunities",
+            help: "Enable pipeline (opportunities)",
+            parse: parseBooleanFlag,
+        },
+        {
+            flags: "--invoiced-target <amount>",
+            option: "invoicedTarget",
+            field: "invoiced_target",
+            help: "Invoicing target",
+            parse: parseDecimal,
+        },
+        {
+            flags: "--color <index>",
+            option: "color",
+            field: "color",
+            help: "Color index (kanban)",
+            parse: parseDecimal,
+        },
+        {
+            flags: "--sequence <n>",
+            option: "sequence",
+            field: "sequence",
+            help: "Sort sequence",
+            parse: parseDecimal,
+        },
+    ],
+};
+export const crmTeams = {
+    model: "crm.team",
+    showCommand: "odoo crm teams show",
+    defaultListFields: [
+        "id",
+        "name",
+        "user_id",
+        "active",
+        "is_favorite",
+        "create_date",
+    ],
+    showExtraFields: [
+        "company_id",
+        "use_leads",
+        "use_opportunities",
+        "invoiced_target",
+        "color",
+        "sequence",
+        "member_ids",
+        "write_date",
+    ],
+    resolutionHints: {
+        user_id: "--team-leader",
+    },
+    priorityLabels: {},
+    pinnedDomain: [],
+    references: {
+        assignee: {
+            model: "res.users",
+            label: "team leader",
+            field: "user_id",
+            searchFields: ["login", "email", "name"],
+        },
+    },
+    mutation: crmTeamsMutation,
+};
+function parseCount(raw, flag) {
+    if (!/^\d+$/.test(raw)) {
+        throw usageError(`invalid ${flag} value ${JSON.stringify(raw)}`, "expected a non-negative integer");
+    }
+    return Number(raw);
+}
+function parseFieldList(raw) {
+    const fields = raw
+        .split(",")
+        .map((f) => f.trim())
+        .filter((f) => f !== "");
+    if (fields.length === 0) {
+        throw usageError("--fields requires at least one field name");
+    }
+    return fields;
+}
+export async function teamsListCommand(opts, globals) {
+    const client = await authenticatedClient(globals);
+    if (opts.domain && opts.filter && opts.filter.length > 0) {
+        throw usageError("--domain and --filter are mutually exclusive", "pick one filtering form");
+    }
+    const limit = parseCount(opts.limit, "--limit");
+    const offset = parseCount(opts.offset, "--offset");
+    const fieldsMeta = await ModelFields.load(client, "crm.team");
+    const domain = [];
+    if (opts.archived) {
+        domain.push(["active", "=", false]);
+    }
+    else {
+        domain.push(["active", "=", true]);
+    }
+    if (opts.domain) {
+        domain.push(...parseDomain(opts.domain));
+    }
+    else if (opts.filter && opts.filter.length > 0) {
+        domain.push(...buildFilterClauses(opts.filter, fieldsMeta, {
+            user_id: "--team-leader",
+        }));
+    }
+    const fields = opts.fields
+        ? parseFieldList(opts.fields)
+        : crmTeams.defaultListFields;
+    for (const field of fields) {
+        if (field !== "id" && !fieldsMeta.get(field)) {
+            throw usageError(`unknown field ${JSON.stringify(field)} on crm.team`, `run \`odoo crm teams show <id> --all-fields\` to see available fields`);
+        }
+    }
+    const order = opts.order ?? "id asc";
+    // active_test:false so Odoo returns both active and archived rows; the
+    // domain above does the actual active filtering.
+    const kwargs = {
+        fields,
+        limit,
+        offset,
+        order,
+        context: { active_test: false },
+    };
+    const [records, count] = await Promise.all([
+        client.executeKw("crm.team", "search_read", [domain], kwargs),
+        client.executeKw("crm.team", "search_count", [domain], {
+            context: { active_test: false },
+        }),
+    ]);
+    if (globals.json) {
+        printJson({ model: "crm.team", records, count, limit, offset });
+        return;
+    }
+    const headers = fields.map((f) => fieldsMeta.get(f)?.string ?? f);
+    const rows = records.map((rec) => fields.map((f) => humanCell(rec[f])));
+    const color = colorEnabled(globals.noColor);
+    process.stdout.write(formatTable(headers, rows, color) + "\n");
+}
+export function teamsShowCommand(idArg, opts, globals) {
+    return showCommand(crmTeams, idArg, opts, globals);
+}
+export function teamsCreateCommand(opts, globals) {
+    return createCommand(crmTeams, opts, globals);
+}
+export function teamsUpdateCommand(idArgs, opts, globals) {
+    return updateCommand(crmTeams, idArgs, opts, globals);
+}
+export function teamsDeleteCommand(idArgs, globals) {
+    return deleteCommand(crmTeams, idArgs, globals);
+}

package/package.json

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