gdb_backtrace

Instructions

Implementation Reference

• src/index.ts:978-1024 (handler)

  The main handler function for the gdb_backtrace tool. It checks for an active GDB session, builds the backtrace command (with optional full and limit), executes it via executeGdbCommand, and returns the output or error.

  private async handleGdbBacktrace(args: any) {
    const { sessionId, full = false, limit } = args;
    
    if (!activeSessions.has(sessionId)) {
      return {
        content: [
          {
            type: 'text',
            text: `No active GDB session with ID: ${sessionId}`
          }
        ],
        isError: true
      };
    }
    
    const session = activeSessions.get(sessionId)!;
    
    try {
      // Build backtrace command with options
      let command = full ? "backtrace full" : "backtrace";
      if (typeof limit === 'number') {
        command += ` ${limit}`;
      }
      
      const output = await this.executeGdbCommand(session, command);
      
      return {
        content: [
          {
            type: 'text',
            text: `Backtrace${full ? ' (full)' : ''}${limit ? ` (limit: ${limit})` : ''}:\n\n${output}`
          }
        ]
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return {
        content: [
          {
            type: 'text',
            text: `Failed to get backtrace: ${errorMessage}`
          }
        ],
        isError: true
      };
    }
  }

• src/index.ts:270-290 (schema)

  The tool registration object including name, description, and input schema definition for gdb_backtrace.

    name: 'gdb_backtrace',
    description: 'Show call stack',
    inputSchema: {
      type: 'object',
      properties: {
        sessionId: {
          type: 'string',
          description: 'GDB session ID'
        },
        full: {
          type: 'boolean',
          description: 'Show variables in each frame (optional)'
        },
        limit: {
          type: 'number',
          description: 'Maximum number of frames to show (optional)'
        }
      },
      required: ['sessionId']
    }
  },

• src/index.ts:383-384 (registration)

  The switch case in the request handler that routes 'gdb_backtrace' tool calls to the handleGdbBacktrace method.

  case 'gdb_backtrace':
    return await this.handleGdbBacktrace(request.params.arguments);

• src/index.ts:1159-1217 (helper)

  Helper function used by gdb_backtrace to execute the backtrace GDB command and capture its output with timeout and error handling.

  private executeGdbCommand(session: GdbSession, command: string): Promise<string> {
    return new Promise<string>((resolve, reject) => {
      if (!session.ready) {
        reject(new Error('GDB session is not ready'));
        return;
      }
      
      // Write command to GDB's stdin
      if (session.process.stdin) {
        session.process.stdin.write(command + '\n');
      } else {
        reject(new Error('GDB stdin is not available'));
        return;
      }
      
      let output = '';
      let responseComplete = false;
      
      // Create a one-time event handler for GDB output
      const onLine = (line: string) => {
        output += line + '\n';
        
        // Check if this line indicates the end of the GDB response
        if (line.includes('(gdb)') || line.includes('^done') || line.includes('^error')) {
          responseComplete = true;
          
          // If we've received the complete response, resolve the promise
          if (responseComplete) {
            // Remove the listener to avoid memory leaks
            session.rl.removeListener('line', onLine);
            resolve(output);
          }
        }
      };
      
      // Add the line handler to the readline interface
      session.rl.on('line', onLine);
      
      // Set a timeout to prevent hanging
      const timeout = setTimeout(() => {
        session.rl.removeListener('line', onLine);
        reject(new Error('GDB command timed out'));
      }, 10000); // 10 second timeout
      
      // Handle GDB errors
      const errorHandler = (data: Buffer) => {
        const errorText = data.toString();
        output += `[stderr] ${errorText}\n`;
      };
      
      // Add error handler
      if (session.process.stderr) {
        session.process.stderr.once('data', errorHandler);
      }
      
      // Clean up event handlers when the timeout expires
      timeout.unref();
    });
  }