@bergetai/odoo-cli 0.1.0

package/dist/resource.js

@@ -0,0 +1,211 @@
+import { OdooClient } from "./client.js";
+import { missingValueHint, missingValues, resolveConfig } from "./config.js";
+import { parseDurationMs } from "./duration.js";
+import { notFoundError, usageError } from "./errors.js";
+import { buildFilterClauses, parseDomain } from "./filter.js";
+import { ModelFields, resolveReference, stageScopeDomain, } from "./model.js";
+import { colorEnabled, printJson, verbose as logVerbose } from "./output.js";
+import { formatKeyValues, formatTable, humanCell } from "./table.js";
+export const PRIORITY_VALUES = {
+    low: "0",
+    medium: "1",
+    high: "2",
+    urgent: "3",
+};
+/** Parse a --priority flag value into its raw Odoo selection value (§4.5). */
+export function parsePriority(raw, flag = "--priority") {
+    const v = PRIORITY_VALUES[raw];
+    if (v === undefined) {
+        throw usageError(`invalid ${flag} ${JSON.stringify(raw)}`, "expected one of: low, medium, high, urgent");
+    }
+    return v;
+}
+export async function listCommand(config, 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 (SPEC §4.6)");
+    }
+    const booleanish = opts;
+    if (booleanish.open && booleanish.closed) {
+        throw usageError("--open and --closed are mutually exclusive");
+    }
+    const limit = parseCount(opts.limit, "--limit");
+    const offset = parseCount(opts.offset, "--offset");
+    // fields_get first: doubles as the module-installed check (§1), so a
+    // missing model reports "module not installed" before any resolution.
+    const fieldsMeta = await ModelFields.load(client, config.model);
+    // Reference resolution happens before reading the collection itself, so
+    // an unresolvable name fails fast (§4.3). --team resolves before --stage
+    // because stage resolution scopes to the team when both are given (§4.3).
+    const domain = [...config.pinnedDomain];
+    const refs = config.references;
+    let teamId;
+    if (opts.team && refs.team) {
+        const team = await resolveReference(client, refs.team.model, opts.team, {
+            label: refs.team.label,
+        });
+        teamId = team.id;
+        domain.push([refs.team.field, "=", team.id]);
+        logVerbose(`resolved --team "${opts.team}" -> [${team.id}, "${team.name}"]`, globals.verbose);
+    }
+    if (opts.stage && refs.stage) {
+        const stageDomain = teamId !== undefined && refs.team
+            ? await stageScopeDomain(client, refs.stage.model, refs.stage.scope, teamId)
+            : [];
+        const stage = await resolveReference(client, refs.stage.model, opts.stage, {
+            label: refs.stage.label,
+            domain: stageDomain,
+        });
+        domain.push([refs.stage.field, "=", stage.id]);
+        logVerbose(`resolved --stage "${opts.stage}" -> [${stage.id}, "${stage.name}"]`, globals.verbose);
+    }
+    if (opts.assignee && refs.assignee) {
+        const user = await resolveReference(client, refs.assignee.model, opts.assignee, {
+            label: refs.assignee.label,
+            searchFields: refs.assignee.searchFields ?? ["login", "email", "name"],
+        });
+        domain.push([refs.assignee.field, "=", user.id]);
+        logVerbose(`resolved --assignee "${opts.assignee}" -> [${user.id}, "${user.name}"]`, globals.verbose);
+    }
+    for (const tag of opts.tag ?? []) {
+        if (!refs.tag)
+            break;
+        // Repeated --tag filters AND: the record must carry all given tags.
+        const resolved = await resolveReference(client, refs.tag.model, tag, {
+            label: refs.tag.label,
+        });
+        domain.push([refs.tag.field, "=", resolved.id]);
+        logVerbose(`resolved --tag "${tag}" -> [${resolved.id}, "${resolved.name}"]`, globals.verbose);
+    }
+    if (opts.priority) {
+        domain.push(["priority", "=", parsePriority(opts.priority)]);
+    }
+    if (config.extraFilters) {
+        domain.push(...(await config.extraFilters(opts, client)));
+    }
+    if (opts.domain) {
+        domain.push(...parseDomain(opts.domain));
+    }
+    else if (opts.filter && opts.filter.length > 0) {
+        domain.push(...buildFilterClauses(opts.filter, fieldsMeta, config.resolutionHints));
+    }
+    const fields = opts.fields
+        ? parseFieldList(opts.fields)
+        : config.defaultListFields;
+    validateFields(fields, fieldsMeta, config);
+    const order = opts.order ?? "id asc";
+    const [records, count] = await Promise.all([
+        client.executeKw(config.model, "search_read", [domain], {
+            fields,
+            limit,
+            offset,
+            order,
+        }),
+        client.executeKw(config.model, "search_count", [domain]),
+    ]);
+    if (globals.json) {
+        printJson({ model: config.model, records, count, limit, offset });
+        return;
+    }
+    const headers = fields.map((f) => fieldsMeta.get(f)?.string ?? f);
+    const rows = records.map((rec) => fields.map((f) => humanCellWithLabels(config, f, rec[f])));
+    process.stdout.write(formatTable(headers, rows, colorEnabled(globals.noColor)) + "\n");
+}
+export async function showCommand(config, idArg, opts, globals) {
+    const client = await authenticatedClient(globals);
+    const id = parseId(idArg);
+    const fieldsMeta = await ModelFields.load(client, config.model);
+    let fields;
+    if (opts.allFields) {
+        fields = undefined; // no fields kwarg => everything readable
+    }
+    else if (opts.fields) {
+        fields = parseFieldList(opts.fields);
+        validateFields(fields, fieldsMeta, config);
+    }
+    else {
+        // Curated view: intersect with fields_get so edition/version-dependent
+        // fields (e.g. helpdesk.ticket.ticket_type_id) degrade gracefully
+        // instead of faulting the read (SPEC §6.3 defers field verification).
+        const curated = [
+            ...new Set([...config.defaultListFields, ...config.showExtraFields]),
+        ];
+        fields = curated.filter((f) => f === "id" || fieldsMeta.get(f));
+    }
+    const rows = (await client.executeKw(config.model, "read", [[id]], {
+        ...(fields ? { fields } : {}),
+    }));
+    if (rows.length === 0) {
+        throw notFoundError("record_not_found", `no ${config.model} record with id ${id}`);
+    }
+    const record = rows[0];
+    if (globals.json) {
+        printJson({ model: config.model, record });
+        return;
+    }
+    const keys = fields ?? Object.keys(record);
+    const pairs = keys.map((k) => [
+        fieldsMeta.get(k)?.string ?? k,
+        humanCellWithLabels(config, k, record[k]),
+    ]);
+    process.stdout.write(formatKeyValues(pairs, colorEnabled(globals.noColor)) + "\n");
+}
+export function parseId(raw) {
+    if (!/^\d+$/.test(raw)) {
+        throw usageError(`invalid record id ${JSON.stringify(raw)}`, "ids are positive integers");
+    }
+    return Number(raw);
+}
+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;
+}
+function validateFields(fields, meta, config) {
+    for (const field of fields) {
+        if (field === "id")
+            continue;
+        if (!meta.get(field)) {
+            throw usageError(`unknown field ${JSON.stringify(field)} on ${config.model}`, `run \`${config.showCommand} <id> --all-fields\` to see available fields`);
+        }
+    }
+}
+function humanCellWithLabels(config, field, value) {
+    if (field === "priority" && typeof value === "string") {
+        return config.priorityLabels[value] ?? value;
+    }
+    return humanCell(value);
+}
+export async function authenticatedClient(globals) {
+    const resolved = await resolveConfig({
+        url: globals.url,
+        db: globals.db,
+        username: globals.username,
+        apiKeyFile: globals.apiKeyFile,
+    });
+    const missing = missingValues(resolved);
+    if (missing.length > 0) {
+        const details = missing
+            .map((k) => `  ${k}: ${missingValueHint(k)}`)
+            .join("\n");
+        throw usageError(`missing required configuration: ${missing.join(", ")}`, `\n${details}`);
+    }
+    if (!globals.quiet) {
+        process.stderr.write(`Connecting to ${resolved.url} ...\n`);
+    }
+    return new OdooClient(resolved.url, resolved.db, resolved.username, resolved.apiKey, {
+        timeoutMs: parseDurationMs(globals.timeout),
+        verbose: globals.verbose,
+    });
+}

package/dist/table.js

@@ -0,0 +1,44 @@
+/** Terminal color helpers (SPEC §7.2: color sparingly, TTY-gated). */
+export const ansi = {
+    bold: (s, on) => (on ? `${s}` : s),
+    green: (s, on) => (on ? `${s}` : s),
+    red: (s, on) => (on ? `${s}` : s),
+};
+/** Render a human cell value from an Odoo-native value (§7.3 raw forms). */
+export function humanCell(value) {
+    if (value === false || value === null || value === undefined)
+        return "";
+    if (Array.isArray(value)) {
+        // many2one [id, "Name"]
+        if (value.length === 2 && typeof value[0] === "number")
+            return String(value[1]);
+        // x2many id lists
+        return value.join(",");
+    }
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+/**
+ * Aligned table when stdout is a TTY; plain tab-separated rows otherwise so
+ * grep/awk behave (SPEC §7.2).
+ */
+export function formatTable(headers, rows, color) {
+    if (process.stdout.isTTY !== true) {
+        return rows.map((r) => r.join("\t")).join("\n");
+    }
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+    const line = (cells) => cells
+        .map((c, i) => c.padEnd(widths[i]))
+        .join("  ")
+        .trimEnd();
+    const head = line(headers.map((h) => ansi.bold(h, color)));
+    return [head, ...rows.map(line)].join("\n");
+}
+/** key: value block for single-record views. */
+export function formatKeyValues(pairs, color) {
+    const width = Math.max(...pairs.map(([k]) => k.length));
+    return pairs
+        .map(([k, v]) => `${ansi.bold(k.padEnd(width), color)}  ${v}`)
+        .join("\n");
+}

package/dist/xmlrpc.js

@@ -0,0 +1,102 @@
+import { createRequire } from "node:module";
+import { Readable } from "node:stream";
+import { CliError, networkError, usageError } from "./errors.js";
+const require = createRequire(import.meta.url);
+const { serializeMethodCall } = require("xmlrpc/lib/serializer.js");
+const Deserializer = require("xmlrpc/lib/deserializer.js");
+/** Redact anything that looks like key material from verbose output. */
+function redact(text) {
+    return text.replace(/<string>([^<]{6})[^<]*<\/string>/g, "<string>$1…REDACTED</string>");
+}
+function parseResponse(body) {
+    return new Promise((resolve, reject) => {
+        const deserializer = new Deserializer("utf8");
+        const stream = Readable.from([body]);
+        deserializer.deserializeMethodResponse(stream, (error, result) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(result);
+            }
+        });
+    });
+}
+function asFault(error) {
+    if (error instanceof Error &&
+        typeof error.faultCode === "number") {
+        return {
+            faultCode: error.faultCode,
+            faultString: error.message,
+        };
+    }
+    return null;
+}
+/**
+ * One XML-RPC method call against `url`. Exactly one attempt; any transport
+ * or server-side fault surfaces as a CliError (exit 6). Callers that can
+ * distinguish fault payloads (e.g. the db-missing traceback) inspect
+ * `XmlRpcFaultError.faultString` before it is wrapped — see client.ts.
+ */
+export class XmlRpcFaultError extends CliError {
+    faultCode;
+    faultString;
+    constructor(faultCode, faultString) {
+        super("server_fault", `the server reported an error (fault ${faultCode})`, 6, "retry with --verbose to see the full server response");
+        this.name = "XmlRpcFaultError";
+        this.faultCode = faultCode;
+        this.faultString = faultString;
+    }
+}
+export async function callMethod(options, method, params) {
+    let body;
+    try {
+        body = serializeMethodCall(method, params);
+    }
+    catch (cause) {
+        throw usageError(`could not serialize XML-RPC request for ${method}: ${cause.message}`);
+    }
+    if (options.verbose) {
+        process.stderr.write(`--> POST ${options.url} ${method}\n${redact(body)}\n`);
+    }
+    let response;
+    try {
+        response = await fetch(options.url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "text/xml",
+                Accept: "text/xml",
+            },
+            body,
+            signal: AbortSignal.timeout(options.timeoutMs),
+        });
+    }
+    catch (cause) {
+        const err = cause;
+        if (err.name === "TimeoutError" || err.name === "AbortError") {
+            throw networkError(`request to ${options.url} timed out after ${options.timeoutMs}ms`, "check network connectivity or increase --timeout");
+        }
+        throw networkError(`could not reach ${options.url}: ${err.cause ? err.cause.message : err.message}`, "check the URL and your network connection");
+    }
+    const text = await response.text();
+    if (!response.ok) {
+        throw networkError(`server ${options.url} responded with HTTP ${response.status} ${response.statusText}`, options.url.startsWith("http://")
+            ? "the server may require HTTPS"
+            : "check that the URL points to a reachable Odoo server");
+    }
+    if (options.verbose) {
+        process.stderr.write(`<-- HTTP ${response.status}\n${redact(text)}\n`);
+    }
+    let result;
+    try {
+        result = await parseResponse(text);
+    }
+    catch (cause) {
+        const fault = asFault(cause);
+        if (fault) {
+            throw new XmlRpcFaultError(fault.faultCode, fault.faultString);
+        }
+        throw networkError(`could not parse the response from ${options.url} as XML-RPC: ${cause.message}`, "check that the URL points to an Odoo server (expected /xmlrpc/2/common or /xmlrpc/2/object)");
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@bergetai/odoo-cli",
+  "version": "0.1.0",
+  "description": "Agent-first CLI for the Odoo External API",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/berget-ai/odoo-cli.git"
+  },
+  "bugs": "https://github.com/berget-ai/odoo-cli/issues",
+  "homepage": "https://berget.ai",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "npm run build && vitest run",
+    "build": "tsc",
+    "check": "tsc --noEmit"
+  },
+  "keywords": [
+    "odoo",
+    "cli",
+    "erp",
+    "agents"
+  ],
+  "author": "Berget AI",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "odoo": "dist/cli.js"
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "xmlrpc": "^1.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}