doover-js 0.1.2 → 0.2.0-alpha.0

package/dist/node/config-manager.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const auth_profile_1 = require("../auth/auth-profile");
+const errors_1 = require("../auth/errors");
+/**
+ * File-backed profile store compatible with pydoover's config format.
+ *
+ * Reads `~/.doover/config` (or a custom path) synchronously on construction,
+ * matching Python's eager-read model.
+ *
+ * Behaviour:
+ * - Doover2 `[profile=...]` blocks are parsed into `AuthProfile` entries.
+ * - Legacy Doover1 `[...]` blocks and unrecognised raw blocks are preserved
+ *   verbatim in their original order and written back unchanged.
+ * - `write()` creates the `~/.doover` directory if missing.
+ */
+class ConfigManager {
+    constructor(configPath) {
+        this.currentProfile = null;
+        this.current = null;
+        /** Parsed Doover2 profiles keyed by profile name. */
+        this.profiles = new Map();
+        /**
+         * Ordered list of *blocks* in the file as they were originally read. Each
+         * entry is either a `{ type: "managed"; name: string }` reference into
+         * `this.profiles`, or a `{ type: "raw"; text: string }` blob that is
+         * preserved verbatim.
+         */
+        this.blocks = [];
+        this.configPath =
+            configPath ?? path.join(os.homedir(), ".doover", "config");
+        this.read();
+    }
+    // ------------------------------------------------------------------
+    // AuthProfileStore interface
+    // ------------------------------------------------------------------
+    get(profileName) {
+        return this.profiles.get(profileName);
+    }
+    create(entry) {
+        const existing = this.profiles.has(entry.profile);
+        this.profiles.set(entry.profile, entry);
+        if (!existing) {
+            this.blocks.push({ type: "managed", name: entry.profile });
+        }
+    }
+    delete(profileName) {
+        this.profiles.delete(profileName);
+        this.blocks = this.blocks.filter((b) => !(b.type === "managed" && b.name === profileName));
+        if (this.currentProfile === profileName) {
+            this.currentProfile = null;
+            this.current = null;
+        }
+    }
+    write() {
+        const dir = path.dirname(this.configPath);
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        catch (err) {
+            throw new errors_1.DooverAuthError(`Failed to create config directory '${dir}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const sections = [];
+        for (const block of this.blocks) {
+            if (block.type === "raw") {
+                sections.push(block.text);
+            }
+            else {
+                const profile = this.profiles.get(block.name);
+                if (profile) {
+                    sections.push(profile.dumpBlock());
+                }
+            }
+        }
+        try {
+            fs.writeFileSync(this.configPath, sections.join("\n\n") + "\n", "utf-8");
+        }
+        catch (err) {
+            throw new errors_1.DooverAuthError(`Failed to write config file '${this.configPath}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ------------------------------------------------------------------
+    // Internal parsing
+    // ------------------------------------------------------------------
+    read() {
+        let content;
+        try {
+            content = fs.readFileSync(this.configPath, "utf-8");
+        }
+        catch {
+            // File does not exist — start empty.
+            return;
+        }
+        this.profiles.clear();
+        this.blocks = [];
+        const lines = content.split(/\r?\n/);
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            const profileMatch = line.match(/^\[profile=(.+)\]$/);
+            if (profileMatch) {
+                // Doover2 managed block
+                const profileName = profileMatch[1];
+                const bodyLines = [];
+                i++;
+                while (i < lines.length && !lines[i].startsWith("[")) {
+                    bodyLines.push(lines[i]);
+                    i++;
+                }
+                const profile = auth_profile_1.AuthProfile.parse(profileName, bodyLines);
+                this.profiles.set(profileName, profile);
+                this.blocks.push({ type: "managed", name: profileName });
+            }
+            else if (line.match(/^\[.+\]$/) && !line.match(/^\[profile=/)) {
+                // Legacy Doover1 block — preserve verbatim.
+                const rawLines = [line];
+                i++;
+                while (i < lines.length && !lines[i].startsWith("[")) {
+                    rawLines.push(lines[i]);
+                    i++;
+                }
+                this.blocks.push({ type: "raw", text: rawLines.join("\n").trimEnd() });
+            }
+            else {
+                // Stray line outside any block — preserve as raw.
+                if (line.trim()) {
+                    this.blocks.push({ type: "raw", text: line });
+                }
+                i++;
+            }
+        }
+        // Set default current profile to the first managed profile.
+        if (this.profiles.size > 0) {
+            const firstName = this.profiles.keys().next().value;
+            this.currentProfile = firstName;
+            this.current = this.profiles.get(firstName);
+        }
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/node/index.d.ts

@@ -0,0 +1 @@
+export { ConfigManager } from "./config-manager";

package/dist/node/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+var config_manager_1 = require("./config-manager");
+Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return config_manager_1.ConfigManager; } });

package/dist/test/auth.test.d.ts

@@ -0,0 +1 @@
+export {};