@bergetai/odoo-cli 0.9.2 → 0.12.0

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.9.2",
+  "version": "0.12.0",
   "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": {