@aigne/secrets 0.1.6 → 1.74.0-beta

package/lib/esm/keytar.js

@@ -1,149 +0,0 @@
-import { logger } from "@aigne/core/utils/logger.js";
-import { BaseSecretStore } from "./base.js";
-import { isKeyringEnvironmentReady } from "./util.js";
-const DEFAULT_SERVICE_NAME = "-api-key";
-const DEFAULT_ACCOUNT_NAME_FOR_DEFAULT = "default";
-export class KeyringStore extends BaseSecretStore {
-    _impl = null;
-    serviceName;
-    _forceUnavailable;
-    _environmentChecked = false;
-    _environmentReady = false;
-    constructor(options) {
-        super();
-        const { serviceName, forceKeytarUnavailable = false } = options;
-        this.serviceName = `${serviceName}${DEFAULT_SERVICE_NAME}`;
-        this._forceUnavailable = !!forceKeytarUnavailable;
-    }
-    async available() {
-        if (this._forceUnavailable)
-            return false;
-        // Check environment prerequisites before attempting to load the module
-        if (!this._environmentChecked) {
-            const { ready, reason } = isKeyringEnvironmentReady();
-            this._environmentReady = ready;
-            if (!ready) {
-                logger.warn(`Keyring environment not ready: ${reason}`);
-            }
-            this._environmentChecked = true;
-        }
-        if (!this._environmentReady) {
-            return false;
-        }
-        try {
-            if (!this._impl) {
-                const module = await import("@zowe/secrets-for-zowe-sdk");
-                this._impl = module.keyring;
-            }
-            return !!(this._impl &&
-                typeof this._impl.getPassword === "function" &&
-                typeof this._impl.setPassword === "function" &&
-                typeof this._impl.deletePassword === "function");
-        }
-        catch (error) {
-            logger.error(`Failed to load keyring: ${error.message}`);
-            return false;
-        }
-    }
-    async setItem(key, value) {
-        if (!(await this.available()))
-            throw new Error("Keyring not available");
-        if (!this._impl)
-            throw new Error("Keyring not loaded");
-        return this._impl.setPassword(this.serviceName, key, JSON.stringify(value));
-    }
-    async getItem(key) {
-        if (!(await this.available()))
-            return null;
-        if (!this._impl)
-            return null;
-        try {
-            const v = await this._impl.getPassword(this.serviceName, key);
-            if (!v)
-                return null;
-            return this.parseKey(v);
-        }
-        catch {
-            return null;
-        }
-    }
-    async deleteItem(key) {
-        if (!(await this.available()))
-            return false;
-        if (!this._impl)
-            return false;
-        try {
-            const ok = await this._impl.deletePassword(this.serviceName, key);
-            return !!ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async listItems() {
-        if (!(await this.available()))
-            return null;
-        if (!this._impl)
-            return null;
-        try {
-            if (typeof this._impl.findCredentials === "function") {
-                const list = await this._impl.findCredentials(this.serviceName);
-                return Array.isArray(list) && list.length > 0
-                    ? list.filter((c) => c.account !== DEFAULT_ACCOUNT_NAME_FOR_DEFAULT)
-                    : null;
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async listEntries() {
-        const list = await this.listItems();
-        if (!list)
-            return [];
-        return list.reduce((acc, c) => {
-            if (c.password) {
-                const parsed = this.parseKey(c.password);
-                if (parsed)
-                    acc.push(parsed);
-            }
-            return acc;
-        }, []);
-    }
-    async listMap() {
-        const list = await this.listItems();
-        if (!list)
-            return {};
-        return list.reduce((acc, host) => {
-            if (host.account && host.password) {
-                const parsed = this.parseKey(host.password);
-                if (parsed)
-                    acc[host.account] = parsed;
-            }
-            return acc;
-        }, {});
-    }
-    async setDefaultItem(value) {
-        if (!(await this.available()))
-            throw new Error("Keyring not available");
-        if (!this._impl)
-            throw new Error("Keyring not loaded");
-        return this.setItem(DEFAULT_ACCOUNT_NAME_FOR_DEFAULT, value);
-    }
-    async getDefaultItem() {
-        if (!(await this.available()))
-            return null;
-        if (!this._impl)
-            return null;
-        return this.getItem(DEFAULT_ACCOUNT_NAME_FOR_DEFAULT);
-    }
-    async deleteDefaultItem() {
-        if (!(await this.available()))
-            throw new Error("Keyring not available");
-        if (!this._impl)
-            throw new Error("Keyring not loaded");
-        await this.deleteItem(DEFAULT_ACCOUNT_NAME_FOR_DEFAULT);
-    }
-}
-export default KeyringStore;

package/lib/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/lib/esm/types.d.ts

@@ -1,28 +0,0 @@
-export interface CredentialEntry {
-    account: string;
-    password: string | null;
-}
-export interface GetDefaultOptions {
-    fallbackToFirst?: boolean;
-    presetIfFallback?: boolean;
-}
-export interface StoreOptions {
-    filepath?: string;
-    serviceName: string;
-    forceKeytarUnavailable?: boolean;
-}
-export type ItemInfo = {
-    [key: string]: any;
-};
-export interface ISecretStore {
-    available(): Promise<boolean>;
-    setItem(key: string, value: ItemInfo): Promise<void>;
-    getItem(key: string): Promise<ItemInfo | null>;
-    deleteItem(key: string): Promise<boolean>;
-    listItems(): Promise<CredentialEntry[] | null>;
-    listEntries(): Promise<ItemInfo[]>;
-    listMap(): Promise<Record<string, ItemInfo>>;
-    setDefaultItem(value: ItemInfo): Promise<void>;
-    getDefaultItem(options?: GetDefaultOptions): Promise<ItemInfo | null>;
-    deleteDefaultItem(): Promise<void>;
-}

package/lib/esm/types.js

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

package/lib/esm/util.d.ts

@@ -1,4 +0,0 @@
-export declare function isKeyringEnvironmentReady(): {
-    ready: boolean;
-    reason?: string;
-};

package/lib/esm/util.js

@@ -1,54 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-function isWSL() {
-    if (process.platform !== "linux")
-        return false;
-    // env checks
-    if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
-        return true;
-    try {
-        const v = readFileSync("/proc/version", "utf8").toLowerCase();
-        if (v.includes("microsoft") || v.includes("wsl"))
-            return true;
-    }
-    catch { }
-    try {
-        const r = readFileSync("/proc/sys/kernel/osrelease", "utf8").toLowerCase();
-        if (r.includes("microsoft") || r.includes("wsl"))
-            return true;
-    }
-    catch { }
-    // some WSL setups have /run/WSL or other hints
-    if (existsSync("/run/WSL") || existsSync("/run/WSL/"))
-        return true;
-    return false;
-}
-function isDBusAvailable() {
-    return !!process.env.DBUS_SESSION_BUS_ADDRESS;
-}
-function isDisplayAvailable() {
-    return !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
-}
-export function isKeyringEnvironmentReady() {
-    if (process.platform === "win32")
-        return { ready: true };
-    if (process.platform === "darwin")
-        return { ready: true };
-    if (process.platform === "linux") {
-        if (!process.env.CI) {
-            if (isWSL()) {
-                return { ready: false, reason: "Detected WSL (no GNOME keyring by default)" };
-            }
-            // Check for D-Bus (required for libsecret)
-            if (!isDBusAvailable()) {
-                return { ready: false, reason: "D-Bus not available" };
-            }
-            // Check for display server (most keyring services need it)
-            if (!isDisplayAvailable()) {
-                return { ready: false, reason: "Display not available" };
-            }
-        }
-        return { ready: true };
-    }
-    // Unknown platform
-    return { ready: false, reason: `Unsupported platform: ${process.platform}` };
-}