abapgit-agent 1.8.9 → 1.10.0

package/src/utils/debug-daemon.js

@@ -0,0 +1,207 @@
+'use strict';
+
+/**
+ * debug-daemon.js — Long-lived daemon that holds the stateful ADT HTTP connection.
+ *
+ * Why this exists:
+ *   SAP ADT debug sessions are pinned to a specific ABAP work process via the
+ *   SAP_SESSIONID cookie. The cookie is maintained in-memory by AdtHttp. When a
+ *   CLI process exits (e.g. `debug attach --json`) the in-memory session is lost
+ *   and the ABAP work process is released from the debugger. Subsequent CLI
+ *   invocations (`debug step`) get a different HTTP connection → `noSessionAttached`.
+ *
+ *   The daemon keeps one Node.js process alive after attach, holding the open
+ *   HTTP session. Individual CLI commands connect via Unix domain socket, send a
+ *   JSON command, read a JSON response, and exit.
+ *
+ * Lifecycle:
+ *   1. Spawned by `debug attach --json` with detached:true + stdio:ignore + unref()
+ *   2. Reads config/session from env vars (JSON-encoded)
+ *   3. Creates Unix socket at DEBUG_DAEMON_SOCK_PATH
+ *   4. Handles JSON-line commands until `terminate` or 30-min idle timeout
+ *   5. Deletes socket file and exits
+ *
+ * IPC Protocol — newline-delimited JSON over Unix socket:
+ *
+ *   Commands:
+ *     { "cmd": "ping" }
+ *     { "cmd": "step",      "type": "stepOver|stepInto|stepReturn|stepContinue" }
+ *     { "cmd": "vars",      "name": null }
+ *     { "cmd": "stack" }
+ *     { "cmd": "terminate" }
+ *
+ *   Responses (one JSON line per command):
+ *     { "ok": true,  "pong": true }
+ *     { "ok": true,  "position": {...}, "source": [...] }
+ *     { "ok": true,  "variables": [...] }
+ *     { "ok": true,  "frames": [...] }
+ *     { "ok": true,  "terminated": true }
+ *     { "ok": false, "error": "message", "statusCode": 400 }
+ */
+
+const net = require('net');
+const fs  = require('fs');
+const { AdtHttp }      = require('./adt-http');
+const { DebugSession } = require('./debug-session');
+
+const DAEMON_IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Start the daemon server.
+ *
+ * @param {object} config           - ABAP connection config
+ * @param {string} sessionId        - debugSessionId returned by attach
+ * @param {string} socketPath       - Unix socket path to listen on
+ * @param {object|null} snapshot    - { csrfToken, cookies } captured from attach process
+ */
+async function startDaemon(config, sessionId, socketPath, snapshot) {
+  const adt = new AdtHttp(config);
+
+  // Restore the exact SAP_SESSIONID cookie + CSRF token from the attach process.
+  // This guarantees the first IPC command reuses the same ABAP work process
+  // without another round-trip for a new token.
+  if (snapshot && snapshot.csrfToken) adt.csrfToken = snapshot.csrfToken;
+  if (snapshot && snapshot.cookies)   adt.cookies   = snapshot.cookies;
+
+  const session = new DebugSession(adt, sessionId);
+
+  // Remove stale socket file from a previous crash
+  try { fs.unlinkSync(socketPath); } catch (e) { /* ignore ENOENT */ }
+
+  let idleTimer = null;
+
+  function resetIdle() {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(cleanupAndExit, DAEMON_IDLE_TIMEOUT_MS);
+    // unref so idle timer alone doesn't keep the process alive — if the
+    // server stops listening for another reason the process can exit naturally
+    if (idleTimer.unref) idleTimer.unref();
+  }
+
+  function cleanupAndExit(code) {
+    try { fs.unlinkSync(socketPath); } catch (e) { /* ignore */ }
+    process.exit(code || 0);
+  }
+
+  const server = net.createServer((socket) => {
+    resetIdle();
+    let buf = '';
+
+    socket.on('data', (chunk) => {
+      buf += chunk.toString();
+      let idx;
+      while ((idx = buf.indexOf('\n')) !== -1) {
+        const line = buf.slice(0, idx).trim();
+        buf = buf.slice(idx + 1);
+        if (line) {
+          _handleLine(socket, line, session, cleanupAndExit, resetIdle);
+        }
+      }
+    });
+
+    socket.on('error', () => { /* client disconnected abruptly — ignore */ });
+  });
+
+  server.listen(socketPath, () => {
+    resetIdle();
+  });
+
+  server.on('error', (err) => {
+    process.stderr.write(`[debug-daemon] server error: ${err.message}\n`);
+    cleanupAndExit(1);
+  });
+}
+
+/**
+ * Handle one parsed JSON command line.
+ * Exported so unit tests can call it directly without spawning a real server.
+ */
+async function _handleLine(socket, line, session, cleanupAndExit, resetIdle) {
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch (e) {
+    _send(socket, { ok: false, error: `Invalid JSON: ${e.message}` });
+    return;
+  }
+
+  resetIdle();
+
+  try {
+    switch (req.cmd) {
+      case 'ping': {
+        _send(socket, { ok: true, pong: true });
+        break;
+      }
+      case 'step': {
+        const result = await session.step(req.type || 'stepOver');
+        _send(socket, { ok: true, position: result.position, source: result.source });
+        break;
+      }
+      case 'vars': {
+        const variables = await session.getVariables(req.name || null);
+        _send(socket, { ok: true, variables });
+        break;
+      }
+      case 'expand': {
+        const children = await session.getVariableChildren(req.id, req.meta || {});
+        _send(socket, { ok: true, variables: children });
+        break;
+      }
+      case 'stack': {
+        const frames = await session.getStack();
+        _send(socket, { ok: true, frames });
+        break;
+      }
+      case 'terminate': {
+        await session.terminate();
+        _send(socket, { ok: true, terminated: true });
+        // Flush response before exiting — wait for client to close the socket
+        socket.end(() => cleanupAndExit(0));
+        break;
+      }
+      default: {
+        _send(socket, { ok: false, error: `Unknown command: ${req.cmd}` });
+      }
+    }
+  } catch (err) {
+    _send(socket, {
+      ok: false,
+      error: err.message || JSON.stringify(err),
+      statusCode: err.statusCode
+    });
+  }
+}
+
+function _send(socket, obj) {
+  try {
+    socket.write(JSON.stringify(obj) + '\n');
+  } catch (e) {
+    // Client disconnected — ignore
+  }
+}
+
+// ─── Entry point when run as standalone daemon process ────────────────────────
+
+if (require.main === module || process.env.DEBUG_DAEMON_MODE === '1') {
+  const config     = JSON.parse(process.env.DEBUG_DAEMON_CONFIG            || '{}');
+  const sessionId  = process.env.DEBUG_DAEMON_SESSION_ID                   || '';
+  const socketPath = process.env.DEBUG_DAEMON_SOCK_PATH                    || '';
+  const snapshot   = process.env.DEBUG_DAEMON_SESSION_SNAPSHOT
+    ? JSON.parse(process.env.DEBUG_DAEMON_SESSION_SNAPSHOT)
+    : null;
+
+  if (!config.host || !sessionId || !socketPath) {
+    process.stderr.write('[debug-daemon] missing required env vars\n');
+    process.exit(1);
+  }
+
+  startDaemon(config, sessionId, socketPath, snapshot).catch((err) => {
+    process.stderr.write(`[debug-daemon] startup error: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = { startDaemon, _handleLine };

package/src/utils/debug-render.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Shared display helpers for the debug command and REPL.
+ */
+
+/**
+ * Format and print a variable list with dynamic column widths.
+ *
+ * Name display:
+ *   {DATAAGING_TEMPERATURE_DEFAULT} → DATAAGING_TEMPERATURE_DEFAULT  (strip braces)
+ *
+ * Value display:
+ *   {O:N*\CLASS=FOO}           → (FOO)         object reference
+ *   {O:INITIAL}                → (null)         null object reference
+ *   {A:N*\CLASS=FOO\TYPE=BAR}  → (ref: FOO)     data reference
+ *   table                      → [N rows] — use 'x NAME' to expand
+ *   long string                → truncated to 100 chars with …
+ *
+ * @param {Array} variables - [{ name, type, value, metaType, tableLines }]
+ */
+function printVarList(variables) {
+  if (variables.length === 0) {
+    console.log('\n  No variables at current position.');
+    return;
+  }
+
+  // Build display rows first so we can measure column widths.
+  const rows = variables.map(({ name, type, value, metaType, tableLines }) => {
+    const dispName = (name.startsWith('{') && name.endsWith('}')
+      ? name.slice(1, -1)
+      : name).toLowerCase();
+    const dispType = (type || '').toLowerCase();
+
+    let dispValue;
+    if (metaType === 'table') {
+      dispValue = `[${tableLines} rows] — use 'x ${dispName}' to expand`;
+    } else if (typeof value === 'string' && value.startsWith('{O:INITIAL}')) {
+      dispValue = '(null)';
+    } else if (typeof value === 'string' && value.startsWith('{O:')) {
+      const classMatch = value.match(/\\CLASS=([A-Z0-9_]+)/i);
+      dispValue = classMatch ? `(${classMatch[1].toLowerCase()})` : value;
+    } else if (typeof value === 'string' && value.startsWith('{A:')) {
+      const classMatch = value.match(/\\CLASS=([A-Z0-9_]+)/i);
+      dispValue = classMatch ? `(ref: ${classMatch[1].toLowerCase()})` : '(ref)';
+    } else {
+      const str = String(value || '');
+      dispValue = str.length > 100 ? str.slice(0, 100) + '…' : str;
+    }
+
+    return { dispName, dispType, dispValue };
+  });
+
+  const nameW = Math.min(40, Math.max(4, ...rows.map(r => r.dispName.length)));
+  const typeW = Math.min(30, Math.max(4, ...rows.map(r => r.dispType.length)));
+
+  console.log('\n  Variables:\n');
+  console.log('  ' + 'Name'.padEnd(nameW + 2) + 'Type'.padEnd(typeW + 2) + 'Value');
+  console.log('  ' + '-'.repeat(nameW + typeW + 20));
+  rows.forEach(({ dispName, dispType, dispValue }) => {
+    const nameCol = dispName.length > nameW
+      ? dispName.slice(0, nameW - 1) + '…'
+      : dispName.padEnd(nameW + 2);
+    console.log('  ' + nameCol + dispType.padEnd(typeW + 2) + dispValue);
+  });
+  console.log('');
+}
+
+module.exports = { printVarList };

package/src/utils/debug-repl.js

@@ -0,0 +1,256 @@
+'use strict';
+
+/**
+ * Interactive readline REPL for human debug mode.
+ * Entered when `debug attach` is called without --json.
+ */
+const readline = require('readline');
+const { printVarList } = require('./debug-render');
+
+const HELP = `
+  Commands:
+    s  / step          — Step into
+    n  / next          — Step over
+    o  / out           — Step out
+    c  / continue      — Continue execution
+    v  / vars          — Show variables
+    x  / expand <var>  — Drill into a complex variable (table / structure)
+    bt / stack         — Show call stack
+    q  / quit          — Detach debugger (program continues running)
+    kill               — Terminate the running program (hard abort)
+    h  / help          — Show this help
+`;
+
+/**
+ * Render the current debugger state to the terminal.
+ * @param {object} position - { class, method, include, line, ... }
+ * @param {Array}  source   - [{ lineNumber, text, current }]
+ * @param {Array}  variables - [{ name, type, value }]
+ */
+function renderState(position, source, variables) {
+  const where = position.class
+    ? `${position.class}->${position.method}`
+    : (position.method || position.program || '?');
+  const lineRef = position.line ? ` (line ${position.line})` : '';
+
+  console.log(`\n  ABAP Debugger — ${where}${lineRef}`);
+  console.log('  ' + '─'.repeat(55));
+
+  if (source && source.length > 0) {
+    source.forEach(({ lineNumber, text, current }) => {
+      const marker = current ? '>' : ' ';
+      console.log(`  ${marker}${String(lineNumber).padStart(4)}  ${text}`);
+    });
+  }
+
+  if (variables && variables.length > 0) {
+    printVarList(variables);
+  }
+
+  console.log('\n  [s]tep  [n]ext  [o]ut  [c]ontinue  [v]ars  [x]pand  [bt]  [q]uit(detach)  kill');
+}
+
+/**
+ * Start the interactive REPL.
+ * @param {import('./debug-session').DebugSession} session
+ * @param {{ position: object, source: string[] }} initialState
+ * @param {Function} [onBeforeExit]  Optional async cleanup called before process.exit(0)
+ */
+async function startRepl(session, initialState, onBeforeExit) {
+  let { position, source } = initialState;
+  let variables = [];
+  let exitCleanupDone = false;
+  async function runExitCleanup() {
+    if (exitCleanupDone) return;
+    exitCleanupDone = true;
+    if (onBeforeExit) {
+      try { await onBeforeExit(); } catch (e) { /* ignore */ }
+    }
+  }
+
+  try {
+    variables = await session.getVariables();
+  } catch (e) {
+    // Best-effort
+  }
+
+  renderState(position, source, variables);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '\n  debug> '
+  });
+
+  rl.prompt();
+
+  /**
+   * Returns true when the step result contains a meaningful program position.
+   * After `continue` (or a step that runs off the end of a method), ADT returns
+   * an empty stack, leaving position.class / .method / .program all undefined.
+   * That signals the debuggee has completed — no further stepping is possible.
+   */
+  function _hasPosition(pos) {
+    return pos && (pos.class || pos.method || pos.program);
+  }
+
+  /**
+   * Common handler for step results.
+   * Returns true if the session ended (caller should close the REPL).
+   */
+  async function _handleStepResult(result) {
+    position = result.position;
+    source   = result.source;
+    if (!_hasPosition(position)) {
+      console.log('\n  Execution completed — no active breakpoint. Debug session ended.\n');
+      // Program already finished — nothing to terminate or detach; just close.
+      rl.close();
+      return true;
+    }
+    variables = await session.getVariables().catch(() => []);
+    renderState(position, source, variables);
+    return false;
+  }
+
+  rl.on('line', async (line) => {
+    const cmd = line.trim().toLowerCase();
+
+    try {
+      if (cmd === 's' || cmd === 'step') {
+        if (await _handleStepResult(await session.step('stepInto'))) return;
+
+      } else if (cmd === 'n' || cmd === 'next') {
+        if (await _handleStepResult(await session.step('stepOver'))) return;
+
+      } else if (cmd === 'o' || cmd === 'out') {
+        if (await _handleStepResult(await session.step('stepOut'))) return;
+
+      } else if (cmd === 'c' || cmd === 'continue') {
+        console.log('\n  Continuing execution...');
+        if (await _handleStepResult(await session.step('continue'))) return;
+
+      } else if (cmd === 'v' || cmd === 'vars') {
+        variables = await session.getVariables();
+        printVarList(variables);
+
+      } else if (cmd.startsWith('x ') || cmd.startsWith('expand ')) {
+        const varExpr = cmd.replace(/^(x|expand)\s+/i, '').trim().toUpperCase();
+        if (!varExpr) {
+          console.log('  Usage: x <variable-name>  or  x <parent>-><child>');
+        } else {
+          // Normalize ABAP-style field accessors to use -> separator.
+          const normalizedExpr = varExpr
+            .replace(/\](-(?!>))/g, ']->') // [N]-FIELD → [N]->FIELD
+            .replace(/\*(-(?!>))/g, '*->'); // *-FIELD   → *->FIELD
+          const pathParts = normalizedExpr.split('->').map(s => s.replace(/^-+|-+$/g, '').trim()).filter(Boolean);
+
+          if (pathParts.length > 1) {
+            // Multi-segment path — use session.expandPath
+            try {
+              const { variable: target, children } = await session.expandPath(pathParts);
+              _renderChildren(varExpr, target, children);
+            } catch (err) {
+              console.log(`\n  Error: ${err.message}`);
+            }
+          } else {
+            // Single segment — find in last-fetched vars list
+            const target = variables.find(v => v.name.toUpperCase() === varExpr);
+            if (!target) {
+              console.log(`\n  Variable '${varExpr}' not found. Run 'v' to list variables.`);
+            } else if (!target.id) {
+              console.log(`\n  Variable '${varExpr}' has no ADT ID — cannot expand.`);
+            } else {
+              const meta = { metaType: target.metaType || '', tableLines: target.tableLines || 0 };
+              const children = await session.getVariableChildren(target.id, meta);
+              _renderChildren(varExpr, target, children);
+            }
+          }
+        }
+
+
+      } else if (cmd === 'bt' || cmd === 'stack') {
+        const frames = await session.getStack();
+        console.log('\n  Call Stack:');
+        frames.forEach(({ frame, class: cls, method, line }) => {
+          const loc = cls ? `${cls}->${method}` : method;
+          console.log(`    ${String(frame).padStart(3)}  ${loc}  (line ${line})`);
+        });
+
+      } else if (cmd === 'q' || cmd === 'quit') {
+        console.log('\n  Detaching debugger — program will continue running...');
+        try {
+          await session.detach();
+        } catch (e) {
+          // Ignore detach errors
+        }
+        // Clear state AFTER detach so session 2 (takeover) exits via state-file check.
+        await runExitCleanup();
+        rl.close();
+        return;
+
+      } else if (cmd === 'kill') {
+        console.log('\n  Terminating program (hard abort)...');
+        try {
+          await session.terminate();
+        } catch (e) {
+          // Ignore terminate errors
+        }
+        await runExitCleanup();
+        rl.close();
+        return;
+
+      } else if (cmd === 'h' || cmd === 'help' || cmd === '?') {
+        console.log(HELP);
+
+      } else if (cmd !== '') {
+        console.log(`  Unknown command: ${cmd}. Type 'h' for help.`);
+      }
+    } catch (err) {
+      console.error(`\n  Error: ${err.message || JSON.stringify(err)}`);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on('close', async () => {
+    await runExitCleanup();
+    process.exit(0);
+  });
+
+  return new Promise((resolve) => {
+    rl.on('close', resolve);
+  });
+}
+
+/**
+ * Render the children of an expand operation.
+ * Tables show a row-count hint and a path hint for further expansion.
+ *
+ * @param {string} expr     - The expression the user typed (e.g. 'LO_FACTORY->MT_COMMAND_MAP')
+ * @param {object} variable - The expanded variable metadata
+ * @param {Array}  children - The children returned by getVariableChildren / expandPath
+ */
+function _renderChildren(expr, variable, children) {
+  if (children.length === 0) {
+    console.log(`\n  ${expr} — no children (scalar or empty).`);
+    return;
+  }
+
+  // Compute column widths from actual data (min 4/4, capped at 50/25).
+  const nameW = Math.min(50, Math.max(4, ...children.map(c => (c.name || '').length)));
+  const typeW = Math.min(25, Math.max(4, ...children.map(c => (c.type || c.metaType || '').length)));
+
+  console.log(`\n  ${expr} (${(variable.type || variable.metaType || '?').toLowerCase()}):`);
+  console.log('  ' + 'Name'.padEnd(nameW + 2) + 'Type'.padEnd(typeW + 2) + 'Value');
+  console.log('  ' + '-'.repeat(nameW + typeW + 24));
+  children.forEach(({ name, type, value, metaType, tableLines }) => {
+    const displayType  = (type || metaType || '').toLowerCase().slice(0, typeW);
+    const displayName  = name.toLowerCase();
+    const displayValue = metaType === 'table'
+      ? `[${tableLines} rows] — use 'x ${expr}->${displayName}' to expand`
+      : value;
+    console.log('  ' + displayName.padEnd(nameW + 2) + displayType.padEnd(typeW + 2) + displayValue);
+  });
+}
+
+module.exports = { startRepl, renderState };