fraim-framework 2.0.63 → 2.0.64

package/dist/src/local-mcp-server/stdio-server.js

@@ -23,6 +23,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const axios_1 = __importDefault(require("axios"));
 class FraimLocalMCPServer {
     constructor() {
@@ -34,6 +35,7 @@ class FraimLocalMCPServer {
         this.repoInfo = null;
         this.remoteUrl = process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
         this.apiKey = process.env.FRAIM_API_KEY || '';
+        this.localVersion = this.detectLocalVersion();
         if (!this.apiKey) {
             this.logError('❌ FRAIM_API_KEY environment variable is required');
             process.exit(1);
@@ -41,13 +43,36 @@ class FraimLocalMCPServer {
         this.log('🚀 FRAIM Local MCP Server starting...');
         this.log(`📡 Remote server: ${this.remoteUrl}`);
         this.log(`🔑 API key: ${this.apiKey.substring(0, 10)}...`);
+        this.log(`Local MCP version: ${this.localVersion}`);
     }
     log(message) {
         // Log to stderr (stdout is reserved for MCP protocol)
-        console.error(`[FRAIM] ${message}`);
+        const key = this.apiKey || 'MISSING_API_KEY';
+        console.error(`[FRAIM key:${key}] ${message}`);
     }
     logError(message) {
-        console.error(`[FRAIM ERROR] ${message}`);
+        const key = this.apiKey || 'MISSING_API_KEY';
+        console.error(`[FRAIM ERROR key:${key}] ${message}`);
+    }
+    detectLocalVersion() {
+        const candidates = [
+            (0, path_1.join)(__dirname, '..', '..', '..', 'package.json'),
+            (0, path_1.join)(__dirname, '..', '..', 'package.json')
+        ];
+        for (const pkgPath of candidates) {
+            try {
+                if (!(0, fs_1.existsSync)(pkgPath))
+                    continue;
+                const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
+                if (typeof pkg.version === 'string' && pkg.version.trim().length > 0) {
+                    return pkg.version;
+                }
+            }
+            catch {
+                // Ignore and try the next candidate
+            }
+        }
+        return 'unknown';
     }
     findProjectRoot() {
         // If we already have workspace root from MCP roots, use it
@@ -475,30 +500,31 @@ class FraimLocalMCPServer {
      * Proxy request to remote FRAIM server
      */
     async proxyToRemote(request) {
+        const requestId = (0, crypto_1.randomUUID)();
         try {
             // Special handling for fraim_connect - automatically inject machine and repo info
             if (request.method === 'tools/call' && request.params?.name === 'fraim_connect') {
-                this.log('🔧 Intercepting fraim_connect to inject machine/repo info');
+                this.log(`[req:${requestId}] Intercepting fraim_connect to inject machine/repo info`);
                 const args = request.params.arguments || {};
                 // REQUIRED: Auto-detect and inject machine info
                 const detectedMachine = this.detectMachineInfo();
                 args.machine = {
-                    ...detectedMachine,
-                    ...args.machine // Allow agent to override specific fields if needed
+                    ...args.machine, // Agent values as fallback
+                    ...detectedMachine // Detected values override (always win)
                 };
-                this.log(`✅ Injected machine info: ${args.machine.hostname} (${args.machine.platform})`);
+                this.log(`[req:${requestId}] Auto-detected and injected machine info: ${args.machine.hostname} (${args.machine.platform}), ${Math.round(args.machine.memory / 1024 / 1024 / 1024)}GB RAM, ${args.machine.cpus} CPUs`);
                 // REQUIRED: Auto-detect and inject repo info
                 const detectedRepo = this.detectRepoInfo();
                 if (detectedRepo) {
                     args.repo = {
-                        ...detectedRepo,
-                        ...args.repo // Allow agent to override specific fields if needed
+                        ...args.repo, // Agent values as fallback
+                        ...detectedRepo // Detected values override (always win)
                     };
-                    this.log(`✅ Injected repo info: ${args.repo.owner}/${args.repo.name}`);
+                    this.log(`[req:${requestId}] Auto-detected and injected repo info: ${args.repo.owner}/${args.repo.name}`);
                 }
                 else {
                     // If detection fails completely, return error instead of sending garbage
-                    this.logError('⚠️ Could not detect repo info and no config available');
+                    this.logError(`[req:${requestId}] Could not detect repo info and no config available`);
                     return {
                         jsonrpc: '2.0',
                         id: request.id,
@@ -511,23 +537,53 @@ class FraimLocalMCPServer {
                 // Update the request with injected info
                 request.params.arguments = args;
             }
+            this.log(`[req:${requestId}] Proxying ${request.method} to ${this.remoteUrl}/mcp`);
             const response = await axios_1.default.post(`${this.remoteUrl}/mcp`, request, {
                 headers: {
                     'Content-Type': 'application/json',
-                    'x-api-key': this.apiKey
+                    'x-api-key': this.apiKey,
+                    'x-fraim-request-id': requestId,
+                    'x-fraim-local-version': this.localVersion
                 },
                 timeout: 30000
             });
             return response.data;
         }
         catch (error) {
-            this.logError(`Remote request failed: ${error.message}`);
+            const status = error?.response?.status;
+            const remoteData = error?.response?.data;
+            this.logError(`[req:${requestId}] Remote request failed (${status || 'no-status'}): ${error.message}`);
+            if (remoteData && typeof remoteData === 'object') {
+                const forwarded = {
+                    jsonrpc: typeof remoteData.jsonrpc === 'string' ? remoteData.jsonrpc : '2.0',
+                    id: remoteData.id ?? request.id,
+                    error: remoteData.error ?? {
+                        code: -32603,
+                        message: `Remote server error (${status || 'unknown status'}): ${error.message}`
+                    }
+                };
+                if (forwarded.error && typeof forwarded.error === 'object') {
+                    const existingData = forwarded.error.data;
+                    forwarded.error.data = {
+                        ...(existingData && typeof existingData === 'object' ? existingData : {}),
+                        fraimRequestId: requestId,
+                        remoteStatus: status ?? null,
+                        localMcpVersion: this.localVersion
+                    };
+                }
+                return forwarded;
+            }
             return {
                 jsonrpc: '2.0',
                 id: request.id,
                 error: {
                     code: -32603,
-                    message: `Remote server error: ${error.message}`
+                    message: `Remote server error: ${error.message}`,
+                    data: {
+                        fraimRequestId: requestId,
+                        remoteStatus: status ?? null,
+                        localMcpVersion: this.localVersion
+                    }
                 }
             };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.63",
+  "version": "2.0.64",
   "description": "FRAIM v2: Framework for Rigor-based AI Management - Transform from solo developer to AI manager orchestrating production-ready code with enterprise-grade discipline",
   "main": "index.js",
   "bin": {
@@ -15,7 +15,7 @@
     "start:fraim": "tsx src/fraim-mcp-server.ts",
     "dev:fraim": "tsx --watch src/fraim-mcp-server.ts",
     "serve:website": "node fraim-pro/serve.js",
-    "watch:fraimlogs": "tsx scripts/watch-fraim-logs.ts",
+    "watch:fraimlogs": "tsx scripts/watch-fraim-logs.ts > prodlogs.log 2>&1",
     "manage-keys": "tsx scripts/fraim/manage-keys.ts",
     "view-signups": "tsx scripts/view-signups.ts",
     "fraim:init": "npm run build && node index.js init",

package/registry/stubs/workflows/azure/cost-optimization.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: cost-optimization
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("cost-optimization")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Enable AI agents to systematically analyze Azure subscription costs, identify optimization opportunities, and implement cost-saving measures while maintaining production reliability.