@lanonasis/oauth-client 1.2.5 → 1.2.6

package/dist/index.cjs

@@ -368,11 +368,26 @@ var DesktopOAuthFlow = class extends BaseOAuthFlow {
 };
 
 // src/storage/token-storage.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var os = __toESM(require("os"), 1);
-var crypto2 = __toESM(require("crypto"), 1);
-var fsPromises = fs.promises;
+var _fs = null;
+var _path = null;
+var _os = null;
+var _crypto = null;
+async function getNodeModules() {
+  if (_fs && _path && _os && _crypto) {
+    return { fs: _fs, path: _path, os: _os, crypto: _crypto };
+  }
+  const [fs, path, os, crypto2] = await Promise.all([
+    import("fs"),
+    import("path"),
+    import("os"),
+    import("crypto")
+  ]);
+  _fs = fs;
+  _path = path;
+  _os = os;
+  _crypto = crypto2;
+  return { fs, path, os, crypto: crypto2 };
+}
 var TokenStorage = class {
   constructor() {
     this.storageKey = "lanonasis_mcp_tokens";
@@ -462,25 +477,27 @@ var TokenStorage = class {
   }
   async storeToFile(tokenString) {
     if (!this.isNode()) return;
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules();
     const configDir = path.join(os.homedir(), ".lanonasis");
     const tokenFile = path.join(configDir, "mcp-tokens.enc");
-    await fsPromises.mkdir(configDir, { recursive: true });
-    const key = this.getFileEncryptionKey();
+    await fs.promises.mkdir(configDir, { recursive: true });
+    const key = await this.getFileEncryptionKey();
     const iv = crypto2.randomBytes(16);
     const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
     let encrypted = cipher.update(tokenString, "utf8", "hex");
     encrypted += cipher.final("hex");
     const authTag = cipher.getAuthTag().toString("hex");
     const data = [iv.toString("hex"), authTag, encrypted].join(":");
-    await fsPromises.writeFile(tokenFile, data, { mode: 384 });
+    await fs.promises.writeFile(tokenFile, data, { mode: 384 });
   }
   async retrieveFromFile() {
     if (!this.isNode()) return null;
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules();
     const tokenFile = path.join(os.homedir(), ".lanonasis", "mcp-tokens.enc");
     try {
-      const data = await fsPromises.readFile(tokenFile, "utf8");
+      const data = await fs.promises.readFile(tokenFile, "utf8");
       const parts = data.split(":");
-      const key = this.getFileEncryptionKey();
+      const key = await this.getFileEncryptionKey();
       if (parts.length === 3) {
         const [ivHex, authTagHex, encrypted] = parts;
         const iv = Buffer.from(ivHex, "hex");
@@ -506,13 +523,15 @@ var TokenStorage = class {
   }
   async deleteFile() {
     if (!this.isNode()) return;
+    const { fs, path, os } = await getNodeModules();
     const tokenFile = path.join(os.homedir(), ".lanonasis", "mcp-tokens.enc");
     try {
-      await fsPromises.unlink(tokenFile);
+      await fs.promises.unlink(tokenFile);
     } catch (error) {
     }
   }
-  getFileEncryptionKey() {
+  async getFileEncryptionKey() {
+    const { os, crypto: crypto2 } = await getNodeModules();
     const machineId = os.hostname() + os.userInfo().username;
     const salt = "lanonasis-mcp-oauth-2024";
     return crypto2.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
@@ -652,11 +671,26 @@ var TokenStorage = class {
 };
 
 // src/storage/api-key-storage.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-var os2 = __toESM(require("os"), 1);
-var crypto3 = __toESM(require("crypto"), 1);
-var fsPromises2 = fs2.promises;
+var _fs2 = null;
+var _path2 = null;
+var _os2 = null;
+var _crypto2 = null;
+async function getNodeModules2() {
+  if (_fs2 && _path2 && _os2 && _crypto2) {
+    return { fs: _fs2, path: _path2, os: _os2, crypto: _crypto2 };
+  }
+  const [fs, path, os, crypto2] = await Promise.all([
+    import("fs"),
+    import("path"),
+    import("os"),
+    import("crypto")
+  ]);
+  _fs2 = fs;
+  _path2 = path;
+  _os2 = os;
+  _crypto2 = crypto2;
+  return { fs, path, os, crypto: crypto2 };
+}
 var ApiKeyStorage = class {
   constructor() {
     this.storageKey = "lanonasis_api_key";
@@ -856,31 +890,33 @@ var ApiKeyStorage = class {
   // ==================== Node.js File Storage ====================
   async storeToFile(keyString) {
     if (!this.isNode()) return;
-    const configDir = path2.join(os2.homedir(), ".lanonasis");
-    const keyFile = path2.join(configDir, "api-key.enc");
-    await fsPromises2.mkdir(configDir, { recursive: true, mode: 448 });
-    const key = this.getFileEncryptionKey();
-    const iv = crypto3.randomBytes(16);
-    const cipher = crypto3.createCipheriv("aes-256-gcm", key, iv);
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules2();
+    const configDir = path.join(os.homedir(), ".lanonasis");
+    const keyFile = path.join(configDir, "api-key.enc");
+    await fs.promises.mkdir(configDir, { recursive: true, mode: 448 });
+    const key = await this.getFileEncryptionKey();
+    const iv = crypto2.randomBytes(16);
+    const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
     let encrypted = cipher.update(keyString, "utf8", "hex");
     encrypted += cipher.final("hex");
     const authTag = cipher.getAuthTag();
     const data = iv.toString("hex") + ":" + authTag.toString("hex") + ":" + encrypted;
-    await fsPromises2.writeFile(keyFile, data, { mode: 384 });
+    await fs.promises.writeFile(keyFile, data, { mode: 384 });
   }
   async retrieveFromFile() {
     if (!this.isNode()) return null;
-    const keyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.enc");
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules2();
+    const keyFile = path.join(os.homedir(), ".lanonasis", "api-key.enc");
     try {
-      const data = await fsPromises2.readFile(keyFile, "utf8");
+      const data = await fs.promises.readFile(keyFile, "utf8");
       const [ivHex, authTagHex, encrypted] = data.split(":");
       if (!ivHex || !authTagHex || !encrypted) {
         throw new Error("Invalid encrypted file format");
       }
-      const key = this.getFileEncryptionKey();
+      const key = await this.getFileEncryptionKey();
       const iv = Buffer.from(ivHex, "hex");
       const authTag = Buffer.from(authTagHex, "hex");
-      const decipher = crypto3.createDecipheriv("aes-256-gcm", key, iv);
+      const decipher = crypto2.createDecipheriv("aes-256-gcm", key, iv);
       decipher.setAuthTag(authTag);
       let decrypted = decipher.update(encrypted, "hex", "utf8");
       decrypted += decipher.final("utf8");
@@ -891,33 +927,37 @@ var ApiKeyStorage = class {
   }
   async deleteFile() {
     if (!this.isNode()) return;
-    const keyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.enc");
+    const { fs, path, os } = await getNodeModules2();
+    const keyFile = path.join(os.homedir(), ".lanonasis", "api-key.enc");
     try {
-      await fsPromises2.unlink(keyFile);
+      await fs.promises.unlink(keyFile);
     } catch (error) {
     }
   }
   async retrieveLegacyFromFile() {
     if (!this.isNode()) return null;
-    const legacyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.txt");
+    const { fs, path, os } = await getNodeModules2();
+    const legacyFile = path.join(os.homedir(), ".lanonasis", "api-key.txt");
     try {
-      return await fsPromises2.readFile(legacyFile, "utf8");
+      return await fs.promises.readFile(legacyFile, "utf8");
     } catch {
       return null;
     }
   }
   async deleteLegacyFile() {
     if (!this.isNode()) return;
-    const legacyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.txt");
+    const { fs, path, os } = await getNodeModules2();
+    const legacyFile = path.join(os.homedir(), ".lanonasis", "api-key.txt");
     try {
-      await fsPromises2.unlink(legacyFile);
+      await fs.promises.unlink(legacyFile);
     } catch {
     }
   }
-  getFileEncryptionKey() {
-    const machineId = os2.hostname() + os2.userInfo().username;
+  async getFileEncryptionKey() {
+    const { os, crypto: crypto2 } = await getNodeModules2();
+    const machineId = os.hostname() + os.userInfo().username;
     const salt = "lanonasis-mcp-api-key-2024";
-    return crypto3.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
+    return crypto2.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
   }
   // ==================== Web Encryption ====================
   async encrypt(text) {

package/dist/index.mjs

@@ -332,11 +332,26 @@ var DesktopOAuthFlow = class extends BaseOAuthFlow {
 };
 
 // src/storage/token-storage.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as crypto2 from "crypto";
-var fsPromises = fs.promises;
+var _fs = null;
+var _path = null;
+var _os = null;
+var _crypto = null;
+async function getNodeModules() {
+  if (_fs && _path && _os && _crypto) {
+    return { fs: _fs, path: _path, os: _os, crypto: _crypto };
+  }
+  const [fs, path, os, crypto2] = await Promise.all([
+    import("fs"),
+    import("path"),
+    import("os"),
+    import("crypto")
+  ]);
+  _fs = fs;
+  _path = path;
+  _os = os;
+  _crypto = crypto2;
+  return { fs, path, os, crypto: crypto2 };
+}
 var TokenStorage = class {
   constructor() {
     this.storageKey = "lanonasis_mcp_tokens";
@@ -426,25 +441,27 @@ var TokenStorage = class {
   }
   async storeToFile(tokenString) {
     if (!this.isNode()) return;
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules();
     const configDir = path.join(os.homedir(), ".lanonasis");
     const tokenFile = path.join(configDir, "mcp-tokens.enc");
-    await fsPromises.mkdir(configDir, { recursive: true });
-    const key = this.getFileEncryptionKey();
+    await fs.promises.mkdir(configDir, { recursive: true });
+    const key = await this.getFileEncryptionKey();
     const iv = crypto2.randomBytes(16);
     const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
     let encrypted = cipher.update(tokenString, "utf8", "hex");
     encrypted += cipher.final("hex");
     const authTag = cipher.getAuthTag().toString("hex");
     const data = [iv.toString("hex"), authTag, encrypted].join(":");
-    await fsPromises.writeFile(tokenFile, data, { mode: 384 });
+    await fs.promises.writeFile(tokenFile, data, { mode: 384 });
   }
   async retrieveFromFile() {
     if (!this.isNode()) return null;
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules();
     const tokenFile = path.join(os.homedir(), ".lanonasis", "mcp-tokens.enc");
     try {
-      const data = await fsPromises.readFile(tokenFile, "utf8");
+      const data = await fs.promises.readFile(tokenFile, "utf8");
       const parts = data.split(":");
-      const key = this.getFileEncryptionKey();
+      const key = await this.getFileEncryptionKey();
       if (parts.length === 3) {
         const [ivHex, authTagHex, encrypted] = parts;
         const iv = Buffer.from(ivHex, "hex");
@@ -470,13 +487,15 @@ var TokenStorage = class {
   }
   async deleteFile() {
     if (!this.isNode()) return;
+    const { fs, path, os } = await getNodeModules();
     const tokenFile = path.join(os.homedir(), ".lanonasis", "mcp-tokens.enc");
     try {
-      await fsPromises.unlink(tokenFile);
+      await fs.promises.unlink(tokenFile);
     } catch (error) {
     }
   }
-  getFileEncryptionKey() {
+  async getFileEncryptionKey() {
+    const { os, crypto: crypto2 } = await getNodeModules();
     const machineId = os.hostname() + os.userInfo().username;
     const salt = "lanonasis-mcp-oauth-2024";
     return crypto2.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
@@ -616,11 +635,26 @@ var TokenStorage = class {
 };
 
 // src/storage/api-key-storage.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-import * as crypto3 from "crypto";
-var fsPromises2 = fs2.promises;
+var _fs2 = null;
+var _path2 = null;
+var _os2 = null;
+var _crypto2 = null;
+async function getNodeModules2() {
+  if (_fs2 && _path2 && _os2 && _crypto2) {
+    return { fs: _fs2, path: _path2, os: _os2, crypto: _crypto2 };
+  }
+  const [fs, path, os, crypto2] = await Promise.all([
+    import("fs"),
+    import("path"),
+    import("os"),
+    import("crypto")
+  ]);
+  _fs2 = fs;
+  _path2 = path;
+  _os2 = os;
+  _crypto2 = crypto2;
+  return { fs, path, os, crypto: crypto2 };
+}
 var ApiKeyStorage = class {
   constructor() {
     this.storageKey = "lanonasis_api_key";
@@ -820,31 +854,33 @@ var ApiKeyStorage = class {
   // ==================== Node.js File Storage ====================
   async storeToFile(keyString) {
     if (!this.isNode()) return;
-    const configDir = path2.join(os2.homedir(), ".lanonasis");
-    const keyFile = path2.join(configDir, "api-key.enc");
-    await fsPromises2.mkdir(configDir, { recursive: true, mode: 448 });
-    const key = this.getFileEncryptionKey();
-    const iv = crypto3.randomBytes(16);
-    const cipher = crypto3.createCipheriv("aes-256-gcm", key, iv);
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules2();
+    const configDir = path.join(os.homedir(), ".lanonasis");
+    const keyFile = path.join(configDir, "api-key.enc");
+    await fs.promises.mkdir(configDir, { recursive: true, mode: 448 });
+    const key = await this.getFileEncryptionKey();
+    const iv = crypto2.randomBytes(16);
+    const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
     let encrypted = cipher.update(keyString, "utf8", "hex");
     encrypted += cipher.final("hex");
     const authTag = cipher.getAuthTag();
     const data = iv.toString("hex") + ":" + authTag.toString("hex") + ":" + encrypted;
-    await fsPromises2.writeFile(keyFile, data, { mode: 384 });
+    await fs.promises.writeFile(keyFile, data, { mode: 384 });
   }
   async retrieveFromFile() {
     if (!this.isNode()) return null;
-    const keyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.enc");
+    const { fs, path, os, crypto: crypto2 } = await getNodeModules2();
+    const keyFile = path.join(os.homedir(), ".lanonasis", "api-key.enc");
     try {
-      const data = await fsPromises2.readFile(keyFile, "utf8");
+      const data = await fs.promises.readFile(keyFile, "utf8");
       const [ivHex, authTagHex, encrypted] = data.split(":");
       if (!ivHex || !authTagHex || !encrypted) {
         throw new Error("Invalid encrypted file format");
       }
-      const key = this.getFileEncryptionKey();
+      const key = await this.getFileEncryptionKey();
       const iv = Buffer.from(ivHex, "hex");
       const authTag = Buffer.from(authTagHex, "hex");
-      const decipher = crypto3.createDecipheriv("aes-256-gcm", key, iv);
+      const decipher = crypto2.createDecipheriv("aes-256-gcm", key, iv);
       decipher.setAuthTag(authTag);
       let decrypted = decipher.update(encrypted, "hex", "utf8");
       decrypted += decipher.final("utf8");
@@ -855,33 +891,37 @@ var ApiKeyStorage = class {
   }
   async deleteFile() {
     if (!this.isNode()) return;
-    const keyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.enc");
+    const { fs, path, os } = await getNodeModules2();
+    const keyFile = path.join(os.homedir(), ".lanonasis", "api-key.enc");
     try {
-      await fsPromises2.unlink(keyFile);
+      await fs.promises.unlink(keyFile);
     } catch (error) {
     }
   }
   async retrieveLegacyFromFile() {
     if (!this.isNode()) return null;
-    const legacyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.txt");
+    const { fs, path, os } = await getNodeModules2();
+    const legacyFile = path.join(os.homedir(), ".lanonasis", "api-key.txt");
     try {
-      return await fsPromises2.readFile(legacyFile, "utf8");
+      return await fs.promises.readFile(legacyFile, "utf8");
     } catch {
       return null;
     }
   }
   async deleteLegacyFile() {
     if (!this.isNode()) return;
-    const legacyFile = path2.join(os2.homedir(), ".lanonasis", "api-key.txt");
+    const { fs, path, os } = await getNodeModules2();
+    const legacyFile = path.join(os.homedir(), ".lanonasis", "api-key.txt");
     try {
-      await fsPromises2.unlink(legacyFile);
+      await fs.promises.unlink(legacyFile);
     } catch {
     }
   }
-  getFileEncryptionKey() {
-    const machineId = os2.hostname() + os2.userInfo().username;
+  async getFileEncryptionKey() {
+    const { os, crypto: crypto2 } = await getNodeModules2();
+    const machineId = os.hostname() + os.userInfo().username;
     const salt = "lanonasis-mcp-api-key-2024";
-    return crypto3.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
+    return crypto2.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
   }
   // ==================== Web Encryption ====================
   async encrypt(text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/oauth-client",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "type": "module",
   "description": "OAuth and API Key authentication client for Lan Onasis MCP integration",
   "license": "MIT",