@nextnext/mcp-server 0.1.1 → 0.1.4

package/dist/index.js

@@ -51168,15 +51168,49 @@ var require_main3 = __commonJS((exports) => {
 
 // src/crypto/encryption.ts
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes5 } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+function getOrCreateLocalKey() {
+  if (existsSync(LOCAL_KEY_FILE)) {
+    try {
+      const keyHex2 = readFileSync(LOCAL_KEY_FILE, "utf-8").trim();
+      if (keyHex2.length === 64) {
+        console.error("[Encryption] Using local key from ~/.nextnext/encryption.key");
+        return Buffer.from(keyHex2, "hex");
+      }
+    } catch (error2) {
+      console.error("[Encryption] Error reading local key, generating new one");
+    }
+  }
+  const newKey = randomBytes5(32);
+  const keyHex = newKey.toString("hex");
+  try {
+    if (!existsSync(LOCAL_KEY_DIR)) {
+      mkdirSync(LOCAL_KEY_DIR, { recursive: true, mode: 448 });
+    }
+    writeFileSync(LOCAL_KEY_FILE, keyHex, { mode: 384 });
+    console.error("[Encryption] Generated and saved local key to ~/.nextnext/encryption.key");
+  } catch (error2) {
+    console.error("[Encryption] Could not save local key, using session-only key");
+  }
+  return newKey;
+}
 function getEncryptionKey() {
-  const key = process.env.SERVER_ENCRYPTION_KEY;
-  if (!key) {
-    throw new Error("SERVER_ENCRYPTION_KEY environment variable not set");
+  if (cachedEncryptionKey) {
+    return cachedEncryptionKey;
   }
-  if (key.length !== 64) {
-    throw new Error("SERVER_ENCRYPTION_KEY must be 64 hex characters (32 bytes)");
+  const envKey = process.env.SERVER_ENCRYPTION_KEY;
+  if (envKey) {
+    if (envKey.length !== 64) {
+      throw new Error("SERVER_ENCRYPTION_KEY must be 64 hex characters (32 bytes)");
+    }
+    cachedEncryptionKey = Buffer.from(envKey, "hex");
+    console.error("[Encryption] Using SERVER_ENCRYPTION_KEY from environment");
+    return cachedEncryptionKey;
   }
-  return Buffer.from(key, "hex");
+  cachedEncryptionKey = getOrCreateLocalKey();
+  return cachedEncryptionKey;
 }
 function encryptNostrKey(privateKey) {
   const key = getEncryptionKey();
@@ -51214,11 +51248,14 @@ function isEncryptedNostrKey(value) {
 function generateEncryptionKey() {
   return randomBytes5(32).toString("hex");
 }
+var cachedEncryptionKey = null, LOCAL_KEY_DIR, LOCAL_KEY_FILE;
 var init_encryption = __esm(() => {
+  LOCAL_KEY_DIR = join3(homedir(), ".nextnext");
+  LOCAL_KEY_FILE = join3(LOCAL_KEY_DIR, "encryption.key");
   if (import.meta.url === `file://${process.argv[1]}`) {
     if (process.argv.includes("--generate-key")) {
-      console.log("Generated SERVER_ENCRYPTION_KEY:");
-      console.log(generateEncryptionKey());
+      console.error("Generated SERVER_ENCRYPTION_KEY:");
+      console.error(generateEncryptionKey());
     }
   }
 });
@@ -54223,19 +54260,19 @@ function initRedis() {
   if (url3 && token) {
     redisClient = new Redis2({ url: url3, token });
     useRedis = true;
-    console.log("[Redis] Connected via Upstash REST API");
+    console.error("[Redis] Connected via Upstash REST API");
     return true;
   } else if (url3) {
     try {
       redisClient = Redis2.fromEnv();
       useRedis = true;
-      console.log("[Redis] Connected via REDIS_URL");
+      console.error("[Redis] Connected via REDIS_URL");
       return true;
     } catch (e7) {
       console.warn("[Redis] Failed to connect, falling back to in-memory storage");
     }
   }
-  console.log("[Redis] Not configured, using in-memory storage (data will not survive restarts)");
+  console.error("[Redis] Not configured, using in-memory storage (data will not survive restarts)");
   return false;
 }
 async function getIdentity(pubkey) {
@@ -54313,7 +54350,7 @@ async function markSessionInitialized(sessionId) {
   if (useRedis && redisClient) {
     try {
       await redisClient.set(`${SESSION_PREFIX}${sessionId}`, state, { ex: SESSION_TTL });
-      console.log(`[Redis] Session ${sessionId.slice(0, 8)} marked as initialized`);
+      console.error(`[Redis] Session ${sessionId.slice(0, 8)} marked as initialized`);
     } catch (error2) {
       console.error("[Redis] Error marking session initialized:", error2);
     }
@@ -54381,7 +54418,7 @@ __export(exports_context, {
 import { AsyncLocalStorage } from "async_hooks";
 function runWithSessionContext(sessionId, fn) {
   const cachedIdentity = sessionIdentityCache.get(sessionId);
-  console.log(`[runWithSessionContext] Session: ${sessionId.slice(0, 8)}, cached identity: ${cachedIdentity ? cachedIdentity.npub?.slice(0, 16) || "yes" : "none"}, cache size: ${sessionIdentityCache.size}`);
+  console.error(`[runWithSessionContext] Session: ${sessionId.slice(0, 8)}, cached identity: ${cachedIdentity ? cachedIdentity.npub?.slice(0, 16) || "yes" : "none"}, cache size: ${sessionIdentityCache.size}`);
   return sessionStorage.run({ sessionId, identity: cachedIdentity }, fn);
 }
 function getCurrentSessionId() {
@@ -54401,7 +54438,7 @@ async function authenticateSession(encryptedKey) {
   let privateKeyHex;
   try {
     privateKeyHex = decryptNostrKey(encryptedKey);
-    console.log(`[Session] Decrypted key length: ${privateKeyHex.length}, first4: ${privateKeyHex.slice(0, 4)}`);
+    console.error(`[Session] Decrypted key length: ${privateKeyHex.length}, first4: ${privateKeyHex.slice(0, 4)}`);
   } catch (error2) {
     console.error(`[Session] Decryption failed:`, error2);
     throw new Error(`Decryption failed: ${error2.message}. The key may have been created with a different server or is corrupted.`);
@@ -54413,10 +54450,10 @@ async function authenticateSession(encryptedKey) {
   let pubkey;
   let npub;
   try {
-    console.log(`[Session] Calling getPublicKey with hex (length=${privateKeyHex.length})`);
+    console.error(`[Session] Calling getPublicKey with hex (length=${privateKeyHex.length})`);
     pubkey = getPublicKey2(privateKeyHex);
     npub = nip19_exports.npubEncode(pubkey);
-    console.log(`[Session] Derived pubkey: ${pubkey.slice(0, 8)}...`);
+    console.error(`[Session] Derived pubkey: ${pubkey.slice(0, 8)}...`);
   } catch (error2) {
     console.error(`[Session] getPublicKey failed:`, error2);
     throw new Error(`Failed to derive public key: ${error2.message}`);
@@ -54427,14 +54464,14 @@ async function authenticateSession(encryptedKey) {
     npub
   };
   sessionIdentityCache.set(sessionId, identity);
-  console.log(`[authenticateSession] Cached identity for session ${sessionId.slice(0, 8)}, cache size now: ${sessionIdentityCache.size}`);
+  console.error(`[authenticateSession] Cached identity for session ${sessionId.slice(0, 8)}, cache size now: ${sessionIdentityCache.size}`);
   const store = sessionStorage.getStore();
   if (store) {
     store.identity = identity;
   }
   const existingIdentity = await getIdentity(pubkey);
   if (existingIdentity) {
-    console.log(`[SessionContext] Returning user: ${npub.slice(0, 16)}... (sessions: ${existingIdentity.stats?.totalSessions || 0})`);
+    console.error(`[SessionContext] Returning user: ${npub.slice(0, 16)}... (sessions: ${existingIdentity.stats?.totalSessions || 0})`);
     await recordNewSession(pubkey);
   } else {
     const newIdentity = {
@@ -54448,9 +54485,9 @@ async function authenticateSession(encryptedKey) {
       }
     };
     await saveIdentity(pubkey, newIdentity);
-    console.log(`[SessionContext] New user registered: ${npub.slice(0, 16)}...`);
+    console.error(`[SessionContext] New user registered: ${npub.slice(0, 16)}...`);
   }
-  console.log(`[SessionContext] Session ${sessionId.slice(0, 8)}... authenticated as ${npub.slice(0, 16)}...`);
+  console.error(`[SessionContext] Session ${sessionId.slice(0, 8)}... authenticated as ${npub.slice(0, 16)}...`);
   return identity;
 }
 function clearSessionIdentity() {
@@ -102131,7 +102168,7 @@ function getSupabaseClient() {
   supabase = createClient2(url3, key, {
     auth: { persistSession: false }
   });
-  console.log("[Supabase] Connected to:", url3);
+  console.error("[Supabase] Connected to:", url3);
   return supabase;
 }
 function isSupabaseConfigured() {
@@ -102230,10 +102267,10 @@ async function createBurnerWallet(label, nostrPubkey) {
       label,
       nostrPubkey
     });
-    console.log(`[BurnerWallet] Created (Supabase): ${wallet.address} (${label || "unlabeled"}) ${nostrPubkey ? `linked to ${nostrPubkey.slice(0, 16)}...` : ""}`);
+    console.error(`[BurnerWallet] Created (Supabase): ${wallet.address} (${label || "unlabeled"}) ${nostrPubkey ? `linked to ${nostrPubkey.slice(0, 16)}...` : ""}`);
   } else {
     memoryWallets.set(wallet.id, wallet);
-    console.log(`[BurnerWallet] Created (memory): ${wallet.address} (${label || "unlabeled"})`);
+    console.error(`[BurnerWallet] Created (memory): ${wallet.address} (${label || "unlabeled"})`);
   }
   return wallet;
 }
@@ -102415,7 +102452,7 @@ async function createPaymentAuthorization(walletId, recipientAddress, amountUsdc
       r,
       s: s3
     };
-    console.log(`[x402Payer] Created authorization: ${amountUsdc} USDC from ${account.address} to ${recipientAddress}`);
+    console.error(`[x402Payer] Created authorization: ${amountUsdc} USDC from ${account.address} to ${recipientAddress}`);
     return {
       success: true,
       authorization,
@@ -102442,13 +102479,13 @@ function deriveEvmAddress(nostrPrivateKeyHex) {
 }
 function getCurrentIdentity() {
   const sessionId = getCurrentSessionId();
-  console.log(`[getCurrentIdentity] Session: ${sessionId?.slice(0, 8) || "none"}`);
+  console.error(`[getCurrentIdentity] Session: ${sessionId?.slice(0, 8) || "none"}`);
   const sessionIdentity = getSessionIdentity();
   if (sessionIdentity) {
-    console.log(`[getCurrentIdentity] Found identity: ${sessionIdentity.npub?.slice(0, 16) || sessionIdentity.pubkey.slice(0, 8)}`);
+    console.error(`[getCurrentIdentity] Found identity: ${sessionIdentity.npub?.slice(0, 16) || sessionIdentity.pubkey.slice(0, 8)}`);
     return { pubkey: sessionIdentity.pubkey, privateKeyHex: sessionIdentity.privateKeyHex };
   }
-  console.log(`[getCurrentIdentity] No session identity found`);
+  console.error(`[getCurrentIdentity] No session identity found`);
   const privateKeyHex = process.env.NOSTR_PRIVATE_KEY_HEX;
   if (privateKeyHex) {
     try {
@@ -102684,7 +102721,7 @@ var identityTools = [
 
 // src/tools/wallet-tools.ts
 function identityRequiredResponse(toolName) {
-  console.log(`[${toolName}] No identity found - session may have expired or instance restarted`);
+  console.error(`[${toolName}] No identity found - session may have expired or instance restarted`);
   return {
     content: [{
       type: "text",
@@ -102947,7 +102984,7 @@ var nostrClient = null;
 function getNostrClient() {
   if (!nostrClient) {
     nostrClient = new NostrClient({ relayUrl: RELAY_URL });
-    console.log(`[NostrTools] Initialized with pubkey: ${nostrClient.getPublicKey()}`);
+    console.error(`[NostrTools] Initialized with pubkey: ${nostrClient.getPublicKey()}`);
   }
   return nostrClient;
 }
@@ -102984,13 +103021,13 @@ var postIntentTool = {
         const { authenticateSession: authenticateSession2 } = await Promise.resolve().then(() => (init_context(), exports_context));
         await authenticateSession2(args.encryptedKey);
         identity = getCurrentIdentity();
-        console.log(`[post_intent] Auto-authenticated with provided key`);
+        console.error(`[post_intent] Auto-authenticated with provided key`);
       } catch (error2) {
         console.error(`[post_intent] Auto-auth failed: ${error2.message}`);
       }
     }
     if (!identity) {
-      console.log(`[post_intent] No identity found - session may have expired or instance restarted`);
+      console.error(`[post_intent] No identity found - session may have expired or instance restarted`);
       return {
         content: [{
           type: "text",
@@ -103049,7 +103086,7 @@ var postIntentTool = {
       };
     } catch (error2) {
       console.error("[postIntent] Error routing through Factory-API:", error2);
-      console.log("[postIntent] Falling back to direct relay post...");
+      console.error("[postIntent] Falling back to direct relay post...");
       const client = getNostrClient();
       const result = await client.postIntent(intent);
       return {
@@ -103409,7 +103446,7 @@ class GatewayServer {
 }
 
 // src/config/manager.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 
 // ../../node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -107524,7 +107561,7 @@ class ConfigManager {
   config = null;
   loadFromFile(filePath) {
     try {
-      const fileContent = readFileSync(filePath, "utf-8");
+      const fileContent = readFileSync2(filePath, "utf-8");
       const processedContent = this.substituteEnvVars(fileContent);
       let rawConfig;
       if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
@@ -107612,7 +107649,7 @@ class ConfigManager {
     }
     const enabledServers = config3.servers.filter((s3) => s3.enabled);
     if (enabledServers.length === 0) {
-      console.log("[ConfigManager] No external servers configured. Native tools will be available.");
+      console.error("[ConfigManager] No external servers configured. Native tools will be available.");
     }
   }
 }
@@ -109186,7 +109223,7 @@ function createLogger(logLevel, useStderrOnly = false) {
         if (useStderrOnly) {
           console.error("[INFO]", ...args);
         } else {
-          console.log("[INFO]", ...args);
+          console.error("[INFO]", ...args);
         }
       }
     },
@@ -109217,7 +109254,7 @@ function createLogger(logLevel, useStderrOnly = false) {
   };
 }
 function showHelp() {
-  console.log(`
+  console.error(`
 NextNext MCP Server - Sovereign Shopping Agent
 
 USAGE:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextnext/mcp-server",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "NextNext MCP Server - A sovereign shopping agent with crypto wallet integration",
   "type": "module",
   "main": "dist/index.js",