@proofofprotocol/inscribe-mcp 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proofofprotocol/inscribe-mcp",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Verifiable inscription for AI agents - inscribe anything to blockchain with Hedera HCS",
   "type": "module",
   "main": "src/server.js",

package/src/cli/commands/show.js

@@ -317,75 +317,147 @@ export const showCommand = new Command('show')
     // Debug trace section
     if (options.debug) {
       console.log('');
-      console.log(colors.bold('MCP Sequence Debug Traces'));
+      console.log(colors.bold('MCP Sequence Debug Traces (LAN Analyzer View)'));
       console.log(line);
 
-      const traces = getDebugTraces(logsDir, 50);
+      const traces = getDebugTraces(logsDir, 100);
 
       if (traces.length === 0) {
         console.log(colors.dim('No debug traces found.'));
         console.log('');
-        console.log('To enable debug logging, set environment variable:');
-        console.log(colors.cyan('  export INSCRIBE_MCP_DEBUG=1'));
+        console.log('To enable debug logging:');
+        console.log(colors.cyan('  inscribe-mcp debug on'));
         console.log('');
-        console.log('Then restart the MCP server (restart Claude Desktop).');
+        console.log('Or set environment variable:');
+        console.log(colors.cyan('  export INSCRIBE_MCP_DEBUG=1'));
       } else {
         const sequences = formatSequenceTrace(traces);
 
         if (sequences.length === 0) {
           console.log(colors.dim('No complete sequences found.'));
         } else {
-          // Phase symbols for visual diagram
-          const phaseSymbols = {
-            'agent_to_mcp': '→',
-            'mcp_to_chain': '→',
-            'chain_to_mcp': '←',
-            'mcp_to_agent': '←'
+          // LAN Analyzer style header
+          console.log('');
+          console.log(colors.dim('┌──────────────┬───────┬────────────────────┬───────────────────────────────────────┐'));
+          console.log(colors.dim('│ Timestamp    │ Dir   │ Phase              │ Details                               │'));
+          console.log(colors.dim('├──────────────┼───────┼────────────────────┼───────────────────────────────────────┤'));
+
+          // Direction symbols
+          const dirSymbols = {
+            'IN': colors.green('←IN '),
+            'OUT': colors.cyan('→OUT'),
+            'ERR': colors.red('✗ERR')
           };
 
           const phaseLabels = {
             'agent_to_mcp': 'Agent → MCP',
             'mcp_to_chain': 'MCP → Chain',
             'chain_to_mcp': 'Chain → MCP',
-            'mcp_to_agent': 'MCP → Agent'
+            'mcp_to_agent': 'MCP → Agent',
+            'mcp_error': 'MCP Error'
           };
 
-          console.log('');
-          console.log(colors.dim('  ┌─────────┐      ┌─────────┐      ┌─────────┐'));
-          console.log(colors.dim('  │  Agent  │  →   │   MCP   │  →   │  Chain  │'));
-          console.log(colors.dim('  │(Claude) │  ←   │ Server  │  ←   │ (Hedera)│'));
-          console.log(colors.dim('  └─────────┘      └─────────┘      └─────────┘'));
-          console.log('');
+          for (const seq of sequences.slice(-8)) { // Last 8 sequences
+            // Sequence header
+            const seqTime = new Date(seq.timestamp);
+            const timeStr = seqTime.toLocaleTimeString('en-US', { hour12: false });
+            const msStr = String(seqTime.getMilliseconds()).padStart(3, '0');
 
-          for (const seq of sequences.slice(-5)) { // Last 5 sequences
-            const time = new Date(seq.timestamp).toLocaleTimeString();
-            console.log(colors.bold(`[${time}] ${colors.cyan(seq.tool)}`));
+            console.log(colors.dim('│') + colors.bold(` ${timeStr}.${msStr}`) + colors.dim(' │       │ ') +
+              colors.cyan(colors.bold(`[${seq.tool}]`)).padEnd(28) + colors.dim(' │') +
+              colors.dim(' ─────────────────────────────────────── │'));
 
             for (const phase of seq.phases) {
-              const symbol = phaseSymbols[phase.phase] || '?';
-              const label = phaseLabels[phase.phase] || phase.phase;
-              let detail = '';
+              const phaseTime = new Date(phase.timestamp);
+              const pTimeStr = phaseTime.toLocaleTimeString('en-US', { hour12: false });
+              const pMsStr = String(phaseTime.getMilliseconds()).padStart(3, '0');
+
+              const dir = dirSymbols[phase.direction] || colors.dim('─── ');
+              const phaseLabel = (phaseLabels[phase.phase] || phase.phase).padEnd(18);
+
+              // Build details string based on phase type
+              let details = [];
+
+              // Agent → MCP phase: show method, requestId, args
+              if (phase.phase === 'agent_to_mcp') {
+                if (phase.method) {
+                  details.push(colors.cyan(phase.method));
+                }
+                if (phase.requestId) {
+                  const shortId = String(phase.requestId).slice(-8);
+                  details.push(`id:${shortId}`);
+                }
+                if (phase.argsKeys && phase.argsKeys.length > 0) {
+                  details.push(`[${phase.argsKeys.join(',')}]`);
+                }
+              }
 
-              if (phase.payload) {
-                const payloadStr = JSON.stringify(phase.payload);
-                detail = colors.dim(` ${payloadStr.slice(0, 40)}${payloadStr.length > 40 ? '...' : ''}`);
+              // MCP → Chain phase: show action
+              if (phase.phase === 'mcp_to_chain') {
+                if (phase.action) {
+                  details.push(colors.yellow(phase.action));
+                }
+                if (phase.requestId) {
+                  const shortId = String(phase.requestId).slice(-8);
+                  details.push(`id:${shortId}`);
+                }
               }
-              if (phase.status) {
-                detail = phase.status === 'SUCCESS'
-                  ? colors.green(` ${phase.status}`)
-                  : colors.red(` ${phase.status}`);
+
+              // Chain → MCP phase: show status, duration, txId
+              if (phase.phase === 'chain_to_mcp') {
+                if (phase.status) {
+                  const statusColor = phase.status === 'SUCCESS' ? colors.green : colors.red;
+                  details.push(statusColor(phase.status));
+                }
+                if (phase.duration !== undefined) {
+                  details.push(colors.yellow(`${phase.duration}ms`));
+                }
+                if (phase.resultPreview && phase.resultPreview.txId) {
+                  const shortTx = String(phase.resultPreview.txId).slice(0, 16);
+                  details.push(`tx:${shortTx}...`);
+                }
+                if (phase.error) {
+                  details.push(colors.red(phase.error.slice(0, 20)));
+                }
               }
-              if (phase.txId) {
-                detail += colors.dim(` txId: ${phase.txId}`);
+
+              // MCP → Agent phase: show status, duration, size
+              if (phase.phase === 'mcp_to_agent') {
+                if (phase.status) {
+                  const statusColor = phase.status === 'SUCCESS' ? colors.green : colors.red;
+                  details.push(statusColor(phase.status));
+                }
+                if (phase.duration !== undefined) {
+                  details.push(colors.yellow(`${phase.duration}ms`));
+                }
+                if (phase.responseSize) {
+                  details.push(`${phase.responseSize}b`);
+                }
+                if (phase.error) {
+                  details.push(colors.red(phase.error.slice(0, 20)));
+                }
               }
-              if (phase.result) {
-                detail += colors.dim(` result: ${phase.result}`);
+
+              // MCP Error phase
+              if (phase.phase === 'mcp_error') {
+                if (phase.error) {
+                  details.push(colors.red(phase.error));
+                }
+                if (phase.duration !== undefined) {
+                  details.push(colors.yellow(`${phase.duration}ms`));
+                }
               }
 
-              console.log(`  ${symbol} ${label}${detail}`);
+              const detailStr = details.join(' ').slice(0, 37).padEnd(37);
+
+              console.log(colors.dim('│ ') + `${pTimeStr}.${pMsStr}` + colors.dim(' │ ') +
+                dir + colors.dim(' │ ') + phaseLabel + colors.dim(' │ ') + detailStr + colors.dim(' │'));
             }
-            console.log('');
           }
+
+          console.log(colors.dim('└──────────────┴───────┴────────────────────┴───────────────────────────────────────┘'));
+          console.log('');
+          console.log(colors.dim(`Showing last ${Math.min(8, sequences.length)} of ${sequences.length} sequences`));
         }
       }
     }

package/src/lib/logger.js

@@ -5,7 +5,7 @@
  * Used by MCP Server to record all tool executions.
  */
 
-import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 
@@ -80,6 +80,41 @@ export function logToolExecution({
   });
 }
 
+/**
+ * Check if debug mode is enabled (config or env)
+ */
+function isDebugEnabled() {
+  // Environment variable takes precedence
+  if (process.env.INSCRIBE_MCP_DEBUG === '1' || process.env.INSCRIBE_MCP_DEBUG === 'true') {
+    return true;
+  }
+
+  // Check config file
+  const configPath = join(homedir(), '.inscribe-mcp', 'config.json');
+  if (!existsSync(configPath)) {
+    return false;
+  }
+
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    if (!config.debug || !config.debug.enabled) {
+      return false;
+    }
+
+    // Check expiry
+    if (config.debug.expiresAt) {
+      const expiry = new Date(config.debug.expiresAt);
+      if (Date.now() > expiry.getTime()) {
+        return false; // Expired
+      }
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Log a debug sequence trace
  * @param {Object} options - Debug trace options
@@ -90,10 +125,23 @@ export function logDebugTrace({
   payload = null,
   status = null,
   txId = null,
-  result = null
+  result = null,
+  duration = null,
+  args = null,
+  error = null,
+  // LAN analyzer style additional fields
+  method = null,
+  requestId = null,
+  argsKeys = null,
+  argsPreview = null,
+  action = null,
+  direction = null,
+  resultPreview = null,
+  responseSize = null,
+  errorType = null
 }) {
   // Only log if debug mode is enabled
-  if (!process.env.INSCRIBE_MCP_DEBUG) return;
+  if (!isDebugEnabled()) return;
 
   writeLog({
     level: 'debug',
@@ -102,7 +150,20 @@ export function logDebugTrace({
     payload,
     status,
     txId,
-    result
+    result,
+    duration,
+    args,
+    error,
+    // LAN analyzer style additional fields
+    method,
+    requestId,
+    argsKeys,
+    argsPreview,
+    action,
+    direction,
+    resultPreview,
+    responseSize,
+    errorType
   });
 }
 

package/src/server.js

@@ -20,6 +20,9 @@ import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 
+// Logger for file-based debug traces (import early for use in debugLog)
+import { logDebugTrace } from './lib/logger.js';
+
 /**
  * Check if debug mode is enabled (config or env)
  */
@@ -56,7 +59,7 @@ function isDebugEnabled() {
 }
 
 /**
- * Debug log to stderr (safe for MCP stdio transport)
+ * Debug log to stderr AND file (safe for MCP stdio transport)
  * Checks config on each call for hot-reload support
  */
 function debugLog(phase, data = {}) {
@@ -71,6 +74,16 @@ function debugLog(phase, data = {}) {
 
   // Output to stderr to avoid interfering with MCP JSON-RPC over stdout
   console.error(`[DEBUG] ${JSON.stringify(message)}`);
+
+  // Also write to file for `inscribe-mcp show --debug`
+  logDebugTrace({
+    phase,
+    tool: data.tool,
+    args: data.args,
+    status: data.status,
+    duration: data.duration,
+    error: data.error
+  });
 }
 
 // Layer 1 Tools (Primary)
@@ -136,19 +149,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   const startTime = Date.now();
+  const requestId = request.id || `req_${Date.now()}`;
 
-  // Debug: Agent → MCP (request received)
+  // Debug: Agent → MCP (request received) - LAN analyzer style
   debugLog('agent_to_mcp', {
     tool: name,
-    args: args ? Object.keys(args) : []
+    method: 'tools/call',
+    requestId,
+    argsKeys: args ? Object.keys(args) : [],
+    argsPreview: args ? JSON.stringify(args).slice(0, 100) : null,
+    direction: 'IN'
   });
 
   const tool = allTools.find(t => t.name === name);
 
   if (!tool) {
+    const duration = Date.now() - startTime;
     debugLog('mcp_error', {
       tool: name,
-      error: 'Unknown tool'
+      requestId,
+      error: 'Unknown tool',
+      duration,
+      direction: 'ERR'
     });
 
     return {
@@ -161,25 +183,39 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     // Debug: MCP → Chain (processing)
     debugLog('mcp_to_chain', {
       tool: name,
-      processing: true
+      requestId,
+      action: 'CALL',
+      direction: 'OUT'
     });
 
     const result = await tool.handler(args || {});
     const duration = Date.now() - startTime;
 
+    // Extract key info from result for debug
+    const resultPreview = result ? {
+      success: result.success,
+      txId: result.txId || result.inscription_id || result.topic_id,
+      type: result.type
+    } : null;
+
     // Debug: Chain → MCP (response)
     debugLog('chain_to_mcp', {
       tool: name,
+      requestId,
       status: 'SUCCESS',
       duration,
-      hasResult: !!result
+      resultPreview,
+      direction: 'IN'
     });
 
     // Debug: MCP → Agent (returning result)
     debugLog('mcp_to_agent', {
       tool: name,
+      requestId,
       status: 'SUCCESS',
-      duration
+      duration,
+      responseSize: JSON.stringify(result).length,
+      direction: 'OUT'
     });
 
     return {
@@ -191,17 +227,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     // Debug: Chain → MCP (error)
     debugLog('chain_to_mcp', {
       tool: name,
+      requestId,
       status: 'FAILED',
       duration,
-      error: error.message
+      error: error.message,
+      errorType: error.constructor.name,
+      direction: 'IN'
     });
 
     // Debug: MCP → Agent (returning error)
     debugLog('mcp_to_agent', {
       tool: name,
+      requestId,
       status: 'ERROR',
       duration,
-      error: error.message
+      error: error.message,
+      direction: 'OUT'
     });
 
     return {
@@ -223,7 +264,7 @@ async function main() {
   if (isDebugEnabled()) {
     console.error('Debug mode is currently ON (hot-reloadable)');
     debugLog('server_start', {
-      version: '0.3.4',
+      version: '0.3.6',
       tools: allTools.map(t => t.name)
     });
   }