@bergetai/odoo-cli 0.1.0

package/dist/commands/crm.js

@@ -0,0 +1,198 @@
+import { createCommand, deleteCommand, parseDate, parseDecimal, parsePriorityFlag, parseProbability, updateCommand, } from "../mutation.js";
+import { listCommand, showCommand, } from "../resource.js";
+/** CRM create/update field→flag mapping (§5.3). */
+const crmLeadsMutation = {
+    createPinnedValues: { type: "lead" },
+    flags: [
+        {
+            flags: "--name <name>",
+            option: "name",
+            field: "name",
+            help: "Lead title",
+            requiredOnCreate: true,
+        },
+        {
+            flags: "--company-name <name>",
+            option: "companyName",
+            field: "partner_name",
+            help: "Company name",
+        },
+        {
+            flags: "--contact-name <name>",
+            option: "contactName",
+            field: "contact_name",
+            help: "Contact name",
+        },
+        {
+            flags: "--email <address>",
+            option: "email",
+            field: "email_from",
+            help: "Email",
+        },
+        {
+            flags: "--phone <number>",
+            option: "phone",
+            field: "phone",
+            help: "Phone",
+        },
+        {
+            flags: "--expected-revenue <amount>",
+            option: "expectedRevenue",
+            field: "expected_revenue",
+            help: "Expected revenue",
+            parse: parseDecimal,
+        },
+        {
+            flags: "--probability <percent>",
+            option: "probability",
+            field: "probability",
+            help: "Probability (0–100)",
+            parse: parseProbability,
+        },
+        {
+            flags: "--team <name|id>",
+            option: "team",
+            field: "team_id",
+            help: "Sales team",
+            reference: { model: "crm.team", label: "team" },
+        },
+        {
+            flags: "--stage <name|id>",
+            option: "stage",
+            field: "stage_id",
+            help: "Stage (scoped to --team when given)",
+            reference: {
+                model: "crm.stage",
+                label: "stage",
+                scopedBy: "team",
+                scope: "inclusive",
+            },
+        },
+        {
+            flags: "--assignee <name|id>",
+            option: "assignee",
+            field: "user_id",
+            help: "Salesperson (login, email, or name)",
+            reference: {
+                model: "res.users",
+                label: "user",
+                searchFields: ["login", "email", "name"],
+            },
+        },
+        {
+            flags: "--tag <name|id>",
+            option: "tag",
+            field: "tag_ids",
+            help: "Tag; repeatable, replaces all tags",
+            multi: true,
+            reference: { model: "crm.tag", label: "tag" },
+        },
+        {
+            flags: "--priority <level>",
+            option: "priority",
+            field: "priority",
+            help: "Priority: low|medium|high|urgent",
+            parse: parsePriorityFlag,
+        },
+        {
+            flags: "--deadline <yyyy-mm-dd>",
+            option: "deadline",
+            field: "date_deadline",
+            help: "Expected closing date",
+            parse: parseDate,
+        },
+        {
+            flags: "--source <name|id>",
+            option: "source",
+            field: "source_id",
+            help: "Lead source",
+            reference: { model: "utm.source", label: "source" },
+        },
+        {
+            flags: "--medium <name|id>",
+            option: "medium",
+            field: "medium_id",
+            help: "Lead medium",
+            reference: { model: "utm.medium", label: "medium" },
+        },
+        {
+            flags: "--description <text>",
+            option: "description",
+            field: "description",
+            help: "Notes",
+        },
+    ],
+};
+export const crmLeads = {
+    model: "crm.lead",
+    showCommand: "odoo crm leads show",
+    defaultListFields: [
+        "id",
+        "name",
+        "partner_name",
+        "stage_id",
+        "team_id",
+        "user_id",
+        "expected_revenue",
+        "priority",
+        "date_deadline",
+    ],
+    showExtraFields: [
+        "contact_name",
+        "email_from",
+        "phone",
+        "source_id",
+        "medium_id",
+        "tag_ids",
+        "lost_reason_id",
+        "probability",
+        "create_date",
+        "write_date",
+    ],
+    resolutionHints: {
+        stage_id: "--stage",
+        team_id: "--team",
+        user_id: "--assignee",
+        tag_ids: "--tag",
+    },
+    priorityLabels: {
+        "0": "Low",
+        "1": "Medium",
+        "2": "High",
+        "3": "Very High",
+    },
+    pinnedDomain: [["type", "=", "lead"]],
+    references: {
+        team: { model: "crm.team", label: "team", field: "team_id" },
+        stage: {
+            model: "crm.stage",
+            label: "stage",
+            field: "stage_id",
+            scope: "inclusive",
+        },
+        assignee: {
+            model: "res.users",
+            label: "user",
+            field: "user_id",
+            searchFields: ["login", "email", "name"],
+        },
+        tag: { model: "crm.tag", label: "tag", field: "tag_ids" },
+    },
+    // Phase 3 (§4.4, §4.2, §5.4): dry-run plans for create/update/delete.
+    mutation: crmLeadsMutation,
+};
+export function leadsListCommand(opts, globals) {
+    return listCommand(crmLeads, opts, globals);
+}
+export function leadsShowCommand(idArg, opts, globals) {
+    return showCommand(crmLeads, idArg, opts, globals);
+}
+export function leadsCreateCommand(opts, globals) {
+    return createCommand(crmLeads, opts, globals);
+}
+export function leadsUpdateCommand(idArgs, opts, globals) {
+    return updateCommand(crmLeads, idArgs, opts, globals);
+}
+export function leadsDeleteCommand(idArgs, globals) {
+    return deleteCommand(crmLeads, idArgs, globals);
+}

package/dist/commands/helpdesk.js

@@ -0,0 +1,190 @@
+import { createCommand, deleteCommand, parsePriorityFlag, updateCommand, } from "../mutation.js";
+import { listCommand, showCommand, } from "../resource.js";
+/** Helpdesk create/update field→flag mapping (§6.3). */
+const helpdeskTicketsMutation = {
+    // --partner cannot combine with --customer-email/--customer-name (§6.3):
+    // a ticket either links a partner record or carries free-form customer fields.
+    exclusiveGroups: [
+        {
+            options: ["partner", "customerEmail", "customerName"],
+            hint: "a ticket either links a partner (--partner) or carries free-form customer fields (--customer-email/--customer-name)",
+        },
+    ],
+    flags: [
+        {
+            flags: "--subject <subject>",
+            option: "subject",
+            field: "name",
+            help: "Subject",
+            requiredOnCreate: true,
+        },
+        {
+            flags: "--description <text>",
+            option: "description",
+            field: "description",
+            help: "Description",
+        },
+        {
+            flags: "--team <name|id>",
+            option: "team",
+            field: "team_id",
+            help: "Helpdesk team",
+            reference: { model: "helpdesk.team", label: "team" },
+        },
+        {
+            flags: "--partner <name|id>",
+            option: "partner",
+            field: "partner_id",
+            help: "Customer (by id, exact email, or name)",
+            reference: {
+                model: "res.partner",
+                label: "partner",
+                searchFields: ["name"],
+                exactFields: ["email"],
+            },
+        },
+        {
+            flags: "--customer-email <address>",
+            option: "customerEmail",
+            field: "partner_email",
+            help: "Customer email (without a partner record)",
+            conflictsWith: ["partner"],
+        },
+        {
+            flags: "--customer-name <name>",
+            option: "customerName",
+            field: "partner_name",
+            help: "Customer name (without a partner record)",
+            conflictsWith: ["partner"],
+        },
+        {
+            flags: "--assignee <name|id>",
+            option: "assignee",
+            field: "user_id",
+            help: "Assignee (login, email, or name)",
+            reference: {
+                model: "res.users",
+                label: "user",
+                searchFields: ["login", "email", "name"],
+            },
+        },
+        {
+            flags: "--stage <name|id>",
+            option: "stage",
+            field: "stage_id",
+            help: "Stage (resolved within --team when given)",
+            reference: {
+                model: "helpdesk.stage",
+                label: "stage",
+                scopedBy: "team",
+                scope: "strict",
+            },
+        },
+        {
+            flags: "--priority <level>",
+            option: "priority",
+            field: "priority",
+            help: "Priority: low|medium|high|urgent",
+            parse: parsePriorityFlag,
+        },
+        {
+            flags: "--tag <name|id>",
+            option: "tag",
+            field: "tag_ids",
+            help: "Tag; repeatable, replaces all tags",
+            multi: true,
+            reference: { model: "helpdesk.tag", label: "tag" },
+        },
+        {
+            flags: "--type <name|id>",
+            option: "type",
+            field: "ticket_type_id",
+            help: "Ticket type",
+            reference: {
+                model: "helpdesk.ticket.type",
+                label: "ticket type",
+                mayBeAbsent: true,
+            },
+        },
+    ],
+};
+export const helpdeskTickets = {
+    model: "helpdesk.ticket",
+    showCommand: "odoo helpdesk tickets show",
+    defaultListFields: [
+        "id",
+        "name",
+        "team_id",
+        "stage_id",
+        "user_id",
+        "partner_id",
+        "priority",
+        "create_date",
+    ],
+    showExtraFields: [
+        "description",
+        "partner_name",
+        "partner_email",
+        "tag_ids",
+        "ticket_type_id",
+        "write_date",
+    ],
+    resolutionHints: {
+        stage_id: "--stage",
+        team_id: "--team",
+        user_id: "--assignee",
+        tag_ids: "--tag",
+        partner_id: "--partner",
+    },
+    priorityLabels: {
+        "0": "Low",
+        "1": "Medium",
+        "2": "High",
+        "3": "Urgent",
+    },
+    pinnedDomain: [],
+    references: {
+        team: { model: "helpdesk.team", label: "team", field: "team_id" },
+        stage: {
+            model: "helpdesk.stage",
+            label: "stage",
+            field: "stage_id",
+            scope: "strict",
+        },
+        assignee: {
+            model: "res.users",
+            label: "user",
+            field: "user_id",
+            searchFields: ["login", "email", "name"],
+        },
+        tag: { model: "helpdesk.tag", label: "tag", field: "tag_ids" },
+    },
+    // Phase 3 (§4.4, §4.2, §6.3): dry-run plans for create/update/delete.
+    mutation: helpdeskTicketsMutation,
+    // --open/--closed filter via stage fold (§6.1). fold is a kanban
+    // presentation attribute, conventionally set on closing stages — it is the
+    // only server-side signal available.
+    extraFilters: (opts) => {
+        const o = opts;
+        if (o.open)
+            return Promise.resolve([["stage_id.fold", "=", false]]);
+        if (o.closed)
+            return Promise.resolve([["stage_id.fold", "=", true]]);
+        return Promise.resolve([]);
+    },
+};
+export function ticketsListCommand(opts, globals) {
+    return listCommand(helpdeskTickets, opts, globals);
+}
+export function ticketsShowCommand(idArg, opts, globals) {
+    return showCommand(helpdeskTickets, idArg, opts, globals);
+}
+export function ticketsCreateCommand(opts, globals) {
+    return createCommand(helpdeskTickets, opts, globals);
+}
+export function ticketsUpdateCommand(idArgs, opts, globals) {
+    return updateCommand(helpdeskTickets, idArgs, opts, globals);
+}
+export function ticketsDeleteCommand(idArgs, globals) {
+    return deleteCommand(helpdeskTickets, idArgs, globals);
+}

package/dist/commands/version.js

@@ -0,0 +1,40 @@
+import { OdooClient } from "../client.js";
+import { resolveConfig, missingValueHint, } from "../config.js";
+import { parseDurationMs } from "../duration.js";
+import { usageError } from "../errors.js";
+import { printJson } from "../output.js";
+/**
+ * `odoo version` — unauthenticated connectivity check (SPEC §2.2).
+ * Only --url is required; db/username/key are irrelevant here.
+ */
+export async function versionCommand(globals) {
+    const flags = {
+        url: globals.url,
+        db: globals.db,
+        username: globals.username,
+        apiKeyFile: globals.apiKeyFile,
+    };
+    const resolved = await resolveConfig(flags);
+    if (!resolved.url) {
+        throw usageError("no Odoo URL configured", missingValueHint("url"));
+    }
+    const client = new OdooClient(resolved.url, undefined, undefined, undefined, {
+        timeoutMs: parseDurationMs(globals.timeout),
+        verbose: globals.verbose,
+    });
+    if (!globals.quiet) {
+        process.stderr.write(`Checking ${resolved.url} ...\n`);
+    }
+    const version = await client.version();
+    if (globals.json) {
+        printJson({
+            server_version: version.server_version,
+            server_version_info: version.server_version_info,
+            server_serie: version.server_serie,
+            protocol_version: version.protocol_version,
+        });
+    }
+    else {
+        process.stdout.write(`Odoo ${version.server_version}\n`);
+    }
+}

package/dist/config.js

@@ -0,0 +1,153 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { usageError } from "./errors.js";
+export function configFilePath() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.trim() !== "" ? xdg : join(homedir(), ".config");
+    return join(base, "odoo", "config.json");
+}
+export async function readConfigFile() {
+    const path = configFilePath();
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (cause) {
+        if (cause.code === "ENOENT")
+            return {};
+        throw usageError(`could not read config file ${path}: ${cause.message}`);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw usageError(`config file ${path} is not valid JSON`, "fix the file or re-run `odoo auth login`");
+    }
+}
+const CONFIG_KEYS = ["url", "db", "username", "api_key"];
+/**
+ * Resolve configuration with precedence flags > env > config file (SPEC §2.1).
+ * `overrides.apiKey` represents a key that was already resolved by the caller
+ * (e.g. from stdin during `auth login`) and wins over every channel.
+ */
+export async function resolveConfig(flags, overrides = {}) {
+    const file = await readConfigFile();
+    const apiKeyFileValue = flags.apiKeyFile
+        ? await readApiKeyFile(flags.apiKeyFile)
+        : undefined;
+    const candidates = {
+        url: [
+            [flags.url, "flag"],
+            [process.env.ODOO_URL, "env"],
+            [file.url, "config"],
+        ],
+        db: [
+            [flags.db, "flag"],
+            [process.env.ODOO_DB, "env"],
+            [file.db, "config"],
+        ],
+        username: [
+            [flags.username, "flag"],
+            [process.env.ODOO_USERNAME, "env"],
+            [file.username, "config"],
+        ],
+        api_key: [
+            [overrides.apiKey, "flag"],
+            [process.env.ODOO_API_KEY, "env"],
+            [apiKeyFileValue, "flag"],
+            [file.api_key, "config"],
+        ],
+    };
+    const resolved = {
+        url: undefined,
+        db: undefined,
+        username: undefined,
+        apiKey: undefined,
+        sources: { url: null, db: null, username: null, api_key: null },
+    };
+    for (const key of CONFIG_KEYS) {
+        for (const [value, source] of candidates[key]) {
+            if (value !== undefined && value !== "") {
+                if (key === "api_key")
+                    resolved.apiKey = value;
+                else
+                    resolved[key] = value;
+                resolved.sources[key] = source;
+                break;
+            }
+        }
+    }
+    return resolved;
+}
+async function readApiKeyFile(path) {
+    try {
+        const stat = statSync(path);
+        // Warn (never fail) when the key file is group/world-readable (SPEC §2.1).
+        if (stat.mode & 0o077) {
+            process.stderr.write(`Warning: API key file ${path} is readable by group/others (mode ${(stat.mode & 0o777).toString(8)}); consider chmod 600\n`);
+        }
+    }
+    catch {
+        // statSync failing is reported by the readFile below.
+    }
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (cause) {
+        throw usageError(`could not read API key file ${path}: ${cause.code ?? cause.message}`);
+    }
+    const key = raw.trim();
+    if (key === "") {
+        throw usageError(`API key file ${path} is empty`);
+    }
+    return key;
+}
+/** Atomically write the config file with mode 0600 (SPEC §2.2). */
+export async function writeConfigFile(config) {
+    const path = configFilePath();
+    const tmp = join(dirname(path), `.config.json.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
+    const json = JSON.stringify(config, null, 2) + "\n";
+    mkdirSync(dirname(path), { recursive: true });
+    // mode 0o600 applies at creation; if the temp file somehow exists already,
+    // chmodSync below still enforces the final mode on the renamed file.
+    await writeFile(tmp, json, { encoding: "utf8", mode: 0o600 });
+    try {
+        renameSync(tmp, path);
+    }
+    catch (cause) {
+        rmSync(tmp, { force: true });
+        throw usageError(`could not write config file ${path}: ${cause.message}`);
+    }
+    // renameSync preserves the temp file's mode on POSIX; enforce 0600 regardless
+    // (e.g. across filesystems where the rename falls back to copy).
+    chmodSync(path, 0o600);
+}
+export function missingValues(resolved) {
+    const missing = [];
+    if (!resolved.url)
+        missing.push("url");
+    if (!resolved.db)
+        missing.push("db");
+    if (!resolved.username)
+        missing.push("username");
+    if (!resolved.apiKey)
+        missing.push("api_key");
+    return missing;
+}
+/** Human guidance for where each missing value can be supplied (SPEC §2.2). */
+export function missingValueHint(key) {
+    switch (key) {
+        case "url":
+            return 'set --url, ODOO_URL, or "url" in the config file';
+        case "db":
+            return 'set --db, ODOO_DB, or "db" in the config file';
+        case "username":
+            return 'set --username, ODOO_USERNAME, or "username" in the config file';
+        case "api_key":
+            return "set ODOO_API_KEY, pass --api-key-file, or run `odoo auth login`";
+    }
+}

package/dist/duration.js

@@ -0,0 +1,33 @@
+import { usageError } from "./errors.js";
+const UNIT_MS = {
+    ms: 1,
+    s: 1000,
+    m: 60_000,
+};
+/**
+ * Parse a Go-style duration string into milliseconds.
+ * Accepts `500ms`, `30s`, `1.5m`, `2m30s`, and a bare number meaning seconds.
+ */
+export function parseDurationMs(input) {
+    const trimmed = input.trim();
+    if (trimmed === "") {
+        throw usageError(`invalid --timeout value ${JSON.stringify(input)}`, expectedHint());
+    }
+    // Bare number => seconds.
+    if (/^\d+(\.\d+)?$/.test(trimmed)) {
+        return Number(trimmed) * 1000;
+    }
+    const re = /(\d+(?:\.\d+)?)(ms|s|m)/g;
+    let total = 0;
+    let consumed = "";
+    let match;
+    while ((match = re.exec(trimmed)) !== null) {
+        total += Number(match[1]) * UNIT_MS[match[2]];
+        consumed += match[0];
+    }
+    if (consumed !== trimmed || total <= 0) {
+        throw usageError(`invalid --timeout value ${JSON.stringify(input)}`, expectedHint());
+    }
+    return total;
+}
+const expectedHint = () => "use a Go-style duration (e.g. 500ms, 30s, 1.5m, 2m30s); a bare number means seconds";

package/dist/errors.js

@@ -0,0 +1,21 @@
+/**
+ * CLI error taxonomy. `code` is a stable machine-readable identifier used in
+ * the --json error envelope; `exitCode` follows SPEC §8.
+ */
+export class CliError extends Error {
+    code;
+    exitCode;
+    hint;
+    constructor(code, message, exitCode, hint) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.exitCode = exitCode;
+        this.hint = hint;
+    }
+}
+export const usageError = (message, hint) => new CliError("usage_error", message, 2, hint);
+export const authError = (message, hint) => new CliError("authentication_failed", message, 3, hint);
+export const notFoundError = (code, message, hint) => new CliError(code, message, 4, hint);
+export const conflictError = (code, message, hint) => new CliError(code, message, 5, hint);
+export const networkError = (message, hint) => new CliError("network_error", message, 6, hint);