@bergetai/odoo-cli 0.11.0 → 0.12.1

package/README.md

@@ -16,10 +16,17 @@ Requires Node.js 20 or later.
 
 ```bash
 # Authenticate (API key via stdin — never as a flag)
-pass odoo/key | odoo auth login --url https://acme.odoo.com --db acme --username automation
+pass odoo/key | odoo auth login --profile production --url https://acme.odoo.com --db acme --username automation
+
+# Authenticate a second environment (kept side by side in one config)
+pass odoo/stage-key | odoo auth login --profile stage --url https://odoo.stage.berget.ai --db berget-stage --username automation
+
+# Always select the profile explicitly — commands never guess credentials
+odoo --profile production partners list --company --json
+ODOO_PROFILE=stage odoo partners list --company --json
 
 # Check credentials and their configuration sources
-odoo auth status --json
+odoo auth status --profile production --json
 
 # Unauthenticated connectivity check
 odoo version
@@ -108,7 +115,30 @@ odoo crm records message-delete 253924 258332 --dry-run
 odoo crm records message-delete 253924 258332
 ```
 
-Configuration precedence: flags > environment (`ODOO_URL`, `ODOO_DB`, `ODOO_USERNAME`, `ODOO_API_KEY`) > `$XDG_CONFIG_HOME/odoo/config.json`. The API key is never accepted as a flag value.
+Configuration precedence: flags > environment (`ODOO_URL`, `ODOO_DB`, `ODOO_USERNAME`, `ODOO_API_KEY`) > the selected profile in `$XDG_CONFIG_HOME/odoo/config.toml`. The API key is never accepted as a flag value.
+
+### Profiles
+
+Credentials are stored per **profile** — one TOML table per environment:
+
+```toml
+[profiles.production]
+url = "https://odoo.berget.ai"
+db = "berget"
+username = "automation"
+api_key = "…"
+server_version = "18.0+e"
+
+[profiles.stage]
+url = "https://odoo.stage.berget.ai"
+db = "berget-stage"
+username = "automation"
+api_key = "…"
+```
+
+Every command requires an explicit profile: pass `--profile <name>` or set `ODOO_PROFILE`. Without one the command exits 2 — credentials are never guessed, so a command can never hit the wrong environment by accident. `auth login` and the flags-only `odoo version` check tolerate a profile that does not exist yet (bootstrap), while any other command reports an unknown profile.
+
+Older configs (`config.json`, including top-level credential keys) keep working: they read as the `default` profile and migrate to `config.toml` on the next `auth login` — the legacy file is removed once the TOML config holds everything.
 
 Note: `odoo --version` prints the CLI's own version; `odoo version` queries the server.
 
@@ -127,7 +157,7 @@ Note: `odoo --version` prints the CLI's own version; `odoo version` queries the
 - `--dry-run` for all mutations — full validation, resolution, and before/after diffs without mutating
 - Internal notes (`add-note`) — creates internal Log Notes only (subtype_id=2, message_type=comment), **NEVER sends email to customer**, by design prevents accidental customer communication. Optional `--author <email|name|id>` attributes the note to the partner who actually sent the logged message (resolved via `res.partner`; ambiguous matches list candidates and never guess)
 - Log note correction (`message-update`, `message-delete`) — repair formatting or remove duplicate log notes; strictly limited to comment-type messages (emails/notifications refused by design), full `--dry-run` support, unknown delete ids skipped
-- Config sources and precedence with atomic `0600` config writes, XML-RPC transport with timeouts and HTTPS enforcement, and an auth failure taxonomy (db missing / bad credentials / unreachable)
+- Config profiles (named environments in one `0600` config file, explicit `--profile`/`ODOO_PROFILE` selection), atomic config writes with legacy migration, XML-RPC transport with timeouts and HTTPS enforcement, and an auth failure taxonomy (db missing / bad credentials / unreachable)
 
 ## Compatibility
 

package/dist/cli.js

@@ -60,9 +60,10 @@ CLI's own version, while \`odoo version\` queries the server's version.`)
         .configureHelp({ sortSubcommands: true });
     program.addHelpText("after", `
 Examples:
-  $ pass odoo/key | odoo auth login --url https://acme.odoo.com --db acme --username automation
-  $ odoo auth status --json
-  $ odoo version
+  $ pass odoo/key | odoo auth login --profile production --url https://acme.odoo.com --db acme --username automation
+  $ odoo auth login --profile stage --url https://stage.odoo.com --db stage --username automation
+  $ odoo auth status --profile production --json
+  $ odoo --profile production crm leads list
 
 Docs: https://www.odoo.com/documentation/18.0/developer/reference/external_api.html`);
     applyGlobalOptions(program);
@@ -78,8 +79,8 @@ Docs: https://www.odoo.com/documentation/18.0/developer/reference/external_api.h
         .description("verify credentials and write them to the config file (key via stdin/env/file)")
         .addHelpText("after", `
 Examples:
-  $ pass odoo/key | odoo auth login --url https://acme.odoo.com --db acme --username automation
-  $ ODOO_API_KEY=... odoo auth login --url https://acme.odoo.com --db acme --username automation`)
+  $ pass odoo/key | odoo auth login --profile production --url https://acme.odoo.com --db acme --username automation
+  $ ODOO_API_KEY=... odoo auth login --profile stage --url https://stage.odoo.com --db stage --username automation`)
         .action(async () => {
         await run(authLoginCommand, program);
     });
@@ -1088,6 +1089,7 @@ function collectGlobalOptions(program) {
     return {
         json: Boolean(o.json),
         dryRun: Boolean(o.dryRun),
+        profile: o.profile,
         url: o.url,
         db: o.db,
         username: o.username,

package/dist/commands/auth.js

@@ -1,5 +1,5 @@
 import { OdooClient } from "../client.js";
-import { missingValueHint, missingValues, resolveConfig, writeConfigFile, } from "../config.js";
+import { missingValueHint, missingValues, profileSelectionHint, resolveConfig, resolveProfileName, effectiveProfiles, readConfigFile, writeConfigFile, } from "../config.js";
 import { parseDurationMs } from "../duration.js";
 import { usageError } from "../errors.js";
 import { printJson } from "../output.js";
@@ -12,6 +12,7 @@ async function readStdinKey() {
 }
 function authFlags(globals) {
     return {
+        profile: globals.profile,
         url: globals.url,
         db: globals.db,
         username: globals.username,
@@ -34,9 +35,9 @@ export async function authLoginCommand(globals) {
     else if (!process.env.ODOO_API_KEY && !globals.apiKeyFile) {
         throw usageError("no API key provided", "pipe the key via stdin, set ODOO_API_KEY, or pass --api-key-file — login never prompts");
     }
-    const resolved = await resolveConfig(authFlags(globals), {
-        apiKey: stdinKey,
-    });
+    const resolved = await resolveConfig(authFlags(globals), { apiKey: stdinKey }, 
+    // Bootstrap: the profile may not exist yet — login creates it.
+    { allowUnknownProfile: true });
     const missing = missingValues(resolved);
     if (missing.length > 0) {
         const details = missing
@@ -61,9 +62,10 @@ export async function authLoginCommand(globals) {
         username: resolved.username,
         api_key: resolved.apiKey,
         server_version: version.server_version,
-    });
+    }, resolved.profile);
     if (globals.json) {
         printJson({
+            profile: resolved.profile,
             url: resolved.url,
             db: resolved.db,
             username: resolved.username,
@@ -73,7 +75,7 @@ export async function authLoginCommand(globals) {
         });
     }
     else {
-        process.stdout.write(`Logged in as '${resolved.username}' (uid ${uid}) on ${resolved.url} (Odoo ${version.server_version})\n`);
+        process.stdout.write(`Logged in as '${resolved.username}' (uid ${uid}) on ${resolved.url} (Odoo ${version.server_version}) [profile: ${resolved.profile}]\n`);
     }
 }
 /**
@@ -82,17 +84,50 @@ export async function authLoginCommand(globals) {
  * stdout, even when exiting non-zero (SPEC §7.3 exception).
  */
 export async function authStatusCommand(globals) {
-    const resolved = await resolveConfig(authFlags(globals));
-    const missing = missingValues(resolved);
+    // Profile resolution is handled softly so the §7.3 envelope (with the
+    // missing "profile" key) still reaches stdout under --json, both for a
+    // missing selection and for a selected profile with no stored credentials.
+    const profileName = resolveProfileName(globals);
     const envelope = {
-        url: resolved.url ?? null,
-        db: resolved.db ?? null,
-        username: resolved.username ?? null,
+        profile: profileName ?? null,
+        url: null,
+        db: null,
+        username: null,
         server_version: null,
         uid: null,
         authenticated: false,
-        config_source: resolved.sources,
+        config_source: null,
     };
+    if (!profileName) {
+        const hint = await profileSelectionHint();
+        if (globals.json) {
+            envelope.missing = ["profile"];
+            printJson(envelope);
+        }
+        else {
+            process.stderr.write(`Error: no profile selected — ${hint}\n`);
+        }
+        process.exitCode = 2;
+        return;
+    }
+    const knownProfiles = effectiveProfiles(await readConfigFile());
+    if (!knownProfiles.has(profileName)) {
+        if (globals.json) {
+            envelope.missing = ["profile"];
+            printJson(envelope);
+        }
+        else {
+            process.stderr.write(`Error: no stored credentials for profile ${JSON.stringify(profileName)} — run \`odoo auth login --profile ${profileName} ...\`\n`);
+        }
+        process.exitCode = 2;
+        return;
+    }
+    const resolved = await resolveConfig(authFlags(globals));
+    envelope.url = resolved.url ?? null;
+    envelope.db = resolved.db ?? null;
+    envelope.username = resolved.username ?? null;
+    envelope.config_source = resolved.sources;
+    const missing = missingValues(resolved);
     if (missing.length > 0) {
         envelope.missing = missing;
         if (globals.json) {
@@ -123,6 +158,7 @@ export async function authStatusCommand(globals) {
         printJson(envelope);
     }
     else {
+        process.stdout.write(`Profile:        ${profileName}\n`);
         process.stdout.write(`URL:            ${envelope.url} (${resolved.sources.url})\n`);
         process.stdout.write(`Database:       ${envelope.db} (${resolved.sources.db})\n`);
         process.stdout.write(`Username:       ${envelope.username} (${resolved.sources.username})\n`);

package/dist/commands/version.js

@@ -1,5 +1,5 @@
 import { OdooClient } from "../client.js";
-import { resolveConfig, missingValueHint, } from "../config.js";
+import { resolveConfig, missingValueHint } from "../config.js";
 import { parseDurationMs } from "../duration.js";
 import { usageError } from "../errors.js";
 import { printJson } from "../output.js";
@@ -9,12 +9,16 @@ import { printJson } from "../output.js";
  */
 export async function versionCommand(globals) {
     const flags = {
+        profile: globals.profile,
         url: globals.url,
         db: globals.db,
         username: globals.username,
         apiKeyFile: globals.apiKeyFile,
     };
-    const resolved = await resolveConfig(flags);
+    const resolved = await resolveConfig(flags, {}, 
+    // Flags-only connectivity check — profile values are unused, so a
+    // not-yet-existing profile is fine.
+    { allowUnknownProfile: true });
     if (!resolved.url) {
         throw usageError("no Odoo URL configured", missingValueHint("url"));
     }

package/dist/config.js

@@ -3,8 +3,15 @@ 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 { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 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.toml");
+}
+/** Pre-TOML config location; supported read-only for one-way migration. */
+function legacyConfigFilePath() {
     const xdg = process.env.XDG_CONFIG_HOME;
     const base = xdg && xdg.trim() !== "" ? xdg : join(homedir(), ".config");
     return join(base, "odoo", "config.json");
@@ -15,6 +22,26 @@ export async function readConfigFile() {
     try {
         raw = await readFile(path, "utf8");
     }
+    catch (cause) {
+        // No config.toml — fall back to the legacy JSON config, if any.
+        if (cause.code === "ENOENT") {
+            return readLegacyJsonConfigFile();
+        }
+        throw usageError(`could not read config file ${path}: ${cause.message}`);
+    }
+    try {
+        return parseToml(raw);
+    }
+    catch {
+        throw usageError(`config file ${path} is not valid TOML`, "fix the file or re-run `odoo auth login`");
+    }
+}
+async function readLegacyJsonConfigFile() {
+    const path = legacyConfigFilePath();
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
     catch (cause) {
         if (cause.code === "ENOENT")
             return {};
@@ -27,14 +54,85 @@ export async function readConfigFile() {
         throw usageError(`config file ${path} is not valid JSON`, "fix the file or re-run `odoo auth login`");
     }
 }
+const PROFILE_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/**
+ * Profile selection: `--profile` flag > `ODOO_PROFILE` env. Returns undefined
+ * when neither is set (callers decide whether that is fatal).
+ */
+export function resolveProfileName(flags) {
+    const raw = flags?.profile ?? process.env.ODOO_PROFILE;
+    const name = raw?.trim();
+    if (!name)
+        return undefined;
+    if (!PROFILE_NAME_RE.test(name)) {
+        throw usageError(`invalid profile name ${JSON.stringify(name)}`, "use letters, digits, '.', '_' or '-' (must start with a letter or digit)");
+    }
+    return name;
+}
+/**
+ * Effective profiles: explicit `profiles` entries, plus the legacy top-level
+ * keys, which read as the "default" profile when no profiles.default exists.
+ */
+export function effectiveProfiles(file) {
+    const profiles = new Map();
+    const hasExplicitDefault = Object.hasOwn(file.profiles ?? {}, "default");
+    if (!hasExplicitDefault) {
+        const legacy = {};
+        let hasLegacy = false;
+        for (const key of CONFIG_KEYS) {
+            const value = file[key];
+            if (value !== undefined) {
+                legacy[key] = value;
+                hasLegacy = true;
+            }
+        }
+        if (hasLegacy)
+            profiles.set("default", legacy);
+    }
+    for (const [name, credentials] of Object.entries(file.profiles ?? {})) {
+        profiles.set(name, credentials);
+    }
+    return profiles;
+}
+/** Sorted names of the profiles a config file effectively provides. */
+export async function availableProfileNames() {
+    const profiles = effectiveProfiles(await readConfigFile());
+    return [...profiles.keys()].sort();
+}
+export async function profileSelectionHint() {
+    const available = await availableProfileNames();
+    return available.length > 0
+        ? `pass --profile <name> or set ODOO_PROFILE (configured profiles: ${available.join(", ")})`
+        : "pass --profile <name> or set ODOO_PROFILE (no profiles configured yet — run `odoo auth login --profile <name> ...`)";
+}
 const CONFIG_KEYS = ["url", "db", "username", "api_key"];
 /**
- * Resolve configuration with precedence flags > env > config file (SPEC §2.1).
+ * Resolve configuration with precedence flags > env > profile (SPEC §2.1).
+ * A profile must be selected explicitly (`--profile` or `ODOO_PROFILE`) —
+ * commands never fall back to "some" credentials, so a command can never hit
+ * the wrong environment by accident.
  * `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 = {}) {
+export async function resolveConfig(flags, overrides = {}, options = {}) {
+    const profile = resolveProfileName(flags);
+    if (!profile) {
+        throw usageError("no profile selected", await profileSelectionHint());
+    }
     const file = await readConfigFile();
+    const profiles = effectiveProfiles(file);
+    let credentials = profiles.get(profile);
+    if (!credentials) {
+        if (options.allowUnknownProfile) {
+            // Bootstrap: `auth login`/`version` never read profile values, so a
+            // not-yet-existing profile is fine (all needed values come from
+            // flags/env). Regular commands still fail below.
+            credentials = {};
+        }
+        else {
+            throw usageError(`unknown profile ${JSON.stringify(profile)}`, await profileSelectionHint());
+        }
+    }
     const apiKeyFileValue = flags.apiKeyFile
         ? await readApiKeyFile(flags.apiKeyFile)
         : undefined;
@@ -42,26 +140,27 @@ export async function resolveConfig(flags, overrides = {}) {
         url: [
             [flags.url, "flag"],
             [process.env.ODOO_URL, "env"],
-            [file.url, "config"],
+            [credentials.url, "config"],
         ],
         db: [
             [flags.db, "flag"],
             [process.env.ODOO_DB, "env"],
-            [file.db, "config"],
+            [credentials.db, "config"],
         ],
         username: [
             [flags.username, "flag"],
             [process.env.ODOO_USERNAME, "env"],
-            [file.username, "config"],
+            [credentials.username, "config"],
         ],
         api_key: [
             [overrides.apiKey, "flag"],
             [process.env.ODOO_API_KEY, "env"],
             [apiKeyFileValue, "flag"],
-            [file.api_key, "config"],
+            [credentials.api_key, "config"],
         ],
     };
     const resolved = {
+        profile,
         url: undefined,
         db: undefined,
         username: undefined,
@@ -106,15 +205,25 @@ async function readApiKeyFile(path) {
     }
     return key;
 }
-/** Atomically write the config file with mode 0600 (SPEC §2.2). */
-export async function writeConfigFile(config) {
+/**
+ * Atomically write the credentials for one profile with mode 0600 (SPEC §2.2),
+ * as TOML. Preserves every other profile; the legacy top-level keys and
+ * `config.json` are folded in, so the first write completes the migration.
+ */
+export async function writeConfigFile(config, profile) {
+    const profiles = effectiveProfiles(await readConfigFile());
+    profiles.set(profile, config);
+    const next = { profiles: {} };
+    for (const name of [...profiles.keys()].sort()) {
+        next.profiles[name] = profiles.get(name);
+    }
     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";
+    const tmp = join(dirname(path), `.config.toml.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
+    const toml = `${stringifyToml(next)}\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 });
+    await writeFile(tmp, toml, { encoding: "utf8", mode: 0o600 });
     try {
         renameSync(tmp, path);
     }
@@ -125,6 +234,9 @@ export async function writeConfigFile(config) {
     // 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);
+    // Migration complete: the TOML file now holds everything, so the legacy
+    // JSON config would only risk divergence (it is shadowed on reads).
+    rmSync(legacyConfigFilePath(), { force: true });
 }
 export function missingValues(resolved) {
     const missing = [];

package/dist/global-options.js

@@ -4,6 +4,7 @@ export const DEFAULT_TIMEOUT = "30s";
 export function applyGlobalOptions(cmd) {
     cmd.option("--json", "emit a single JSON object on stdout");
     cmd.option("--dry-run, -n", "preview the mutation without applying it");
+    cmd.option("--profile <name>", "configuration profile to use (env: ODOO_PROFILE)");
     cmd.option("--url <url>", "Odoo server URL (env: ODOO_URL)");
     cmd.option("--db <name>", "database name (env: ODOO_DB)");
     cmd.option("--username <login>", "login (env: ODOO_USERNAME)");

package/dist/resource.js

@@ -189,6 +189,7 @@ function humanCellWithLabels(config, field, value) {
 }
 export async function authenticatedClient(globals) {
     const resolved = await resolveConfig({
+        profile: globals.profile,
         url: globals.url,
         db: globals.db,
         username: globals.username,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bergetai/odoo-cli",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Agent-first CLI for the Odoo External API",
   "publishConfig": {
     "access": "public"
@@ -35,6 +35,7 @@
   },
   "dependencies": {
     "commander": "^15.0.0",
+    "smol-toml": "^1.8.0",
     "xmlrpc": "^1.3.2"
   },
   "devDependencies": {