abapgit-agent 1.10.0 → 1.11.0

package/src/utils/debug-session.js

@@ -25,6 +25,37 @@ const { AdtHttp } = require('./adt-http');
 // Header required to pin all requests to the same ABAP work process.
 const STATEFUL_HEADER = { 'X-sap-adt-sessiontype': 'stateful' };
 
+/**
+ * Retry a debug ADT call up to maxRetries times on transient ICM errors.
+ *
+ * The SAP ICM (load balancer) returns HTTP 400 with an HTML "Service cannot
+ * be reached" body when the target ABAP work process is momentarily unavailable
+ * (e.g. finishing a previous step, or briefly between requests).  This is a
+ * transient condition that resolves within a second or two — retrying is safe
+ * for all debug read/navigation operations.
+ *
+ * @param {function} fn         - Async function to retry (takes no args)
+ * @param {number}   maxRetries - Max additional attempts after the first (default 3)
+ * @param {number}   delayMs    - Wait between retries in ms (default 1000)
+ */
+async function retryOnIcmError(fn, maxRetries = 12, delayMs = 2000) {
+  let lastErr;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const isIcmError = err && err.statusCode === 400 &&
+        err.body && err.body.includes('Service cannot be reached');
+      if (!isIcmError) throw err;
+      lastErr = err;
+      if (attempt < maxRetries) {
+        await new Promise(r => setTimeout(r, delayMs));
+      }
+    }
+  }
+  throw lastErr;
+}
+
 class DebugSession {
   /**
    * @param {AdtHttp} adtHttp   - ADT HTTP client instance (carries session cookie)
@@ -33,6 +64,56 @@ class DebugSession {
   constructor(adtHttp, sessionId) {
     this.http = adtHttp;
     this.sessionId = sessionId;
+    this.pinnedSessionId = null;
+    this._keepaliveTimer = null;
+  }
+
+  /**
+   * Start a periodic keepalive that pings ADT every 30 seconds.
+   * SAP's ICM drops stateful session affinity after ~60 s of idle, causing
+   * subsequent debug requests to route to the wrong work process (HTTP 400).
+   * Calling getStack() regularly keeps the connection warm.
+   * Call stopKeepalive() before detach/terminate to avoid racing the close.
+   */
+  startKeepalive() {
+    if (this._keepaliveTimer) return;
+    this._keepaliveTimer = setInterval(async () => {
+      try { await this.getStack(); } catch (e) { /* best-effort */ }
+    }, 30000);
+    if (this._keepaliveTimer.unref) this._keepaliveTimer.unref();
+  }
+
+  stopKeepalive() {
+    if (this._keepaliveTimer) {
+      clearInterval(this._keepaliveTimer);
+      this._keepaliveTimer = null;
+    }
+  }
+
+  /**
+   * Restore the pinned SAP_SESSIONID into the HTTP client's cookie jar.
+   *
+   * SAP ADT debug sessions are bound to a specific frozen ABAP work process
+   * via the SAP_SESSIONID cookie.  AdtHttp updates this cookie automatically
+   * from every response's Set-Cookie header and replaces it on CSRF refresh
+   * (401/403 retry).  When the cookie rotates mid-session the next request
+   * routes to a different ABAP session that has no debug state, causing
+   * HTTP 400 "Service cannot be reached".
+   *
+   * This method reverts any rotation that occurred since attach() by replacing
+   * the current SAP_SESSIONID value with the one captured at attach time.
+   * It is a no-op when called before attach() (pinnedSessionId is null).
+   */
+  _restorePinnedSession() {
+    if (!this.pinnedSessionId || !this.http.cookies) return;
+
+    // Replace whatever SAP_SESSIONID= value is currently in the cookie jar
+    // with the pinned one.  The cookie jar is a semicolon-separated string,
+    // e.g. "SAP_SESSIONID=ABC123; sap-usercontext=xyz".
+    this.http.cookies = this.http.cookies.replace(
+      /SAP_SESSIONID=[^;]*/,
+      `SAP_SESSIONID=${this.pinnedSessionId}`
+    );
   }
 
   /**
@@ -64,6 +145,14 @@ class DebugSession {
       this.sessionId = debugSessionId;
     }
 
+    // Pin the SAP_SESSIONID cookie that was active when we attached.
+    // All subsequent stateful operations must present this exact cookie so
+    // that SAP routes them to the same frozen ABAP work process.
+    if (this.http.cookies) {
+      const match = this.http.cookies.match(/SAP_SESSIONID=([^;]*)/);
+      if (match) this.pinnedSessionId = match[1];
+    }
+
     return this.sessionId;
   }
 
@@ -94,30 +183,35 @@ class DebugSession {
     // completion.  When the program runs to completion ADT returns HTTP 500
     // (no suspended session left).  Treat both 200 and 500 as "continued".
     if (method === 'stepContinue') {
-      try {
-        await this.http.post(`/sap/bc/adt/debugger?method=${method}`, '', {
-          contentType: 'application/vnd.sap.as+xml',
-          headers: STATEFUL_HEADER
-        });
-        // 200: program hit another breakpoint (or is still running).
-        // Position query is not meaningful until a new breakpoint fires via
-        // the listener, so return the sentinel and let the caller re-attach.
-        return { position: { continued: true }, source: [] };
-      } catch (err) {
-        // 500: debuggee ran to completion, session ended normally.
-        if (err && err.statusCode === 500) {
-          return { position: { continued: true, finished: true }, source: [] };
+      return retryOnIcmError(async () => {
+        this._restorePinnedSession();
+        try {
+          await this.http.post(`/sap/bc/adt/debugger?method=${method}`, '', {
+            contentType: 'application/vnd.sap.as+xml',
+            headers: { ...STATEFUL_HEADER, 'Accept': 'application/xml' }
+          });
+          // 200: program hit another breakpoint (or is still running).
+          // Position query is not meaningful until a new breakpoint fires via
+          // the listener, so return the sentinel and let the caller re-attach.
+          return { position: { continued: true }, source: [] };
+        } catch (err) {
+          // 500: debuggee ran to completion, session ended normally.
+          if (err && err.statusCode === 500) {
+            return { position: { continued: true, finished: true }, source: [] };
+          }
+          throw err;
         }
-        throw err;
-      }
+      });
     }
 
-    await this.http.post(`/sap/bc/adt/debugger?method=${method}`, '', {
-      contentType: 'application/vnd.sap.as+xml',
-      headers: STATEFUL_HEADER
+    return retryOnIcmError(async () => {
+      this._restorePinnedSession();
+      await this.http.post(`/sap/bc/adt/debugger?method=${method}`, '', {
+        contentType: 'application/vnd.sap.as+xml',
+        headers: { ...STATEFUL_HEADER, 'Accept': 'application/xml' }
+      });
+      return this.getPosition();
     });
-
-    return this.getPosition();
   }
 
   /**
@@ -139,6 +233,8 @@ class DebugSession {
    * @returns {Promise<Array<{ name: string, type: string, value: string }>>}
    */
   async getVariables(name = null) {
+    this._restorePinnedSession();
+
     const CT_CHILD = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.ChildVariables';
     const CT_VARS  = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.Variables';
 
@@ -220,6 +316,8 @@ class DebugSession {
    * @returns {Promise<Array<{ id: string, name: string, type: string, value: string }>>}
    */
   async getVariableChildren(parentId, meta = {}) {
+    this._restorePinnedSession();
+
     const CT_VARS  = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.Variables';
     const CT_CHILD = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.ChildVariables';
 
@@ -337,13 +435,31 @@ class DebugSession {
    * @returns {Promise<Array<{ frame: number, class: string, method: string, line: number }>>}
    */
   async getStack() {
-    const { body } = await this.http.post(
-      '/sap/bc/adt/debugger?method=getStack&emode=_&semanticURIs=true', '', {
-        contentType: 'application/vnd.sap.as+xml',
-        headers: STATEFUL_HEADER
+    return retryOnIcmError(async () => {
+      this._restorePinnedSession();
+      // Try newer dedicated stack endpoint first (abap-adt-api v7+ approach)
+      try {
+        const { body } = await this.http.get(
+          '/sap/bc/adt/debugger/stack?emode=_&semanticURIs=true', {
+            accept: 'application/xml',
+            headers: STATEFUL_HEADER
+          }
+        );
+        const frames = parseStack(body);
+        if (frames.length > 0) return frames;
+      } catch (e) {
+        // Fall through to POST approach for any GET failure (including 400 on systems
+        // that don't support the dedicated /debugger/stack endpoint)
       }
-    );
-    return parseStack(body);
+      // Fallback: POST approach (older ADT versions)
+      const { body } = await this.http.post(
+        '/sap/bc/adt/debugger?method=getStack&emode=_&semanticURIs=true', '', {
+          contentType: 'application/vnd.sap.as+xml',
+          headers: { ...STATEFUL_HEADER, 'Accept': 'application/xml' }
+        }
+      );
+      return parseStack(body);
+    });
   }
 
   /**
@@ -531,32 +647,38 @@ class DebugSession {
 
   /**
    * Terminate the debug session.
+   * Retries on transient ICM 400 errors so the ABAP work process is reliably
+   * released even when the system is under load (e.g. during test:all).
    */
   async terminate() {
-    await this.http.post('/sap/bc/adt/debugger?method=terminateDebuggee', '', {
-      contentType: 'application/vnd.sap.as+xml',
-      headers: STATEFUL_HEADER
+    await retryOnIcmError(async () => {
+      this._restorePinnedSession();
+      await this.http.post('/sap/bc/adt/debugger?method=terminateDebuggee', '', {
+        contentType: 'application/vnd.sap.as+xml',
+        headers: STATEFUL_HEADER
+      });
     });
   }
 
   /**
    * Detach from the debuggee without killing it.
-   * Issues a stepContinue so the ABAP program resumes running.
+   * Issues a single stepContinue so the ABAP program resumes running.
+   *
+   * ADT returns HTTP 200 when the WP resumes (regardless of whether it
+   * later hits another breakpoint — there is no way to distinguish "still
+   * running" from "re-hit breakpoint" in the stepContinue response alone).
+   * Sending a second stepContinue to an already-running WP races with the
+   * program's own execution and can stall the WP mid-run (e.g. while a
+   * Code Inspector job is in flight), so we issue exactly one request.
    *
-   * stepContinue is a long-poll in ADT — it only responds when the program
-   * hits another breakpoint (200) or finishes (500), which may be never.
-   * We use postFire() which resolves as soon as the request bytes are
-   * flushed to the TCP send buffer — no need to wait for a response.
-   * The existing session cookies are used so ADT recognises the request.
+   * Callers (e.g. the REPL 'q' handler) must delete all breakpoints before
+   * calling detach() to prevent an immediate re-hit on the same line.
    */
   async detach() {
     try {
-      await this.http.postFire('/sap/bc/adt/debugger?method=stepContinue', '', {
-        contentType: 'application/vnd.sap.as+xml',
-        headers: STATEFUL_HEADER
-      });
+      await this.step('stepContinue');
     } catch (e) {
-      // Ignore — fire-and-forget; errors here mean the session already closed.
+      // Ignore — session may have already closed.
     }
   }
 }

package/src/utils/transport-selector.js

@@ -0,0 +1,289 @@
+/**
+ * Transport selector utility
+ * Resolves a transport request number for the pull command when none is configured.
+ *
+ * Strategy:
+ *   - Non-interactive (AI mode, CI): run a project-configured Node.js hook
+ *   - Interactive (TTY): show a numbered picker (list, scope-switch, create, skip)
+ */
+
+const path = require('path');
+
+/**
+ * Returns true when running non-interactively (no TTY, CI, AI coding tool).
+ * Can be forced with NO_TTY=1 env var.
+ */
+function isNonInteractive() {
+  if (process.env.NO_TTY === '1') return true;
+  return !process.stdout.isTTY || !process.stdin.isTTY;
+}
+
+/**
+ * Load and execute a hook module.
+ * The hook must export an async function({ config, http }) → string|null.
+ *
+ * @param {string} hookPath - Absolute path to the hook module
+ * @param {object} context  - { config, http }
+ * @returns {Promise<string|null>}
+ */
+async function runHook(hookPath, context) {
+  const hookFn = require(hookPath);
+  const result = await hookFn(context);
+  return typeof result === 'string' ? result : null;
+}
+
+/**
+ * Fetch open transport requests from ABAP.
+ * Returns normalised lowercase-key objects.
+ *
+ * @param {object} http
+ * @param {string} scope - 'mine' | 'task' | 'all'
+ * @returns {Promise<Array>}
+ */
+async function fetchTransports(http, scope = 'mine') {
+  try {
+    const result = await http.get(`/sap/bc/z_abapgit_agent/transport?scope=${scope}`);
+    const raw = result.TRANSPORTS || result.transports || [];
+    return raw.map(t => ({
+      number:      t.NUMBER      || t.number      || '',
+      description: t.DESCRIPTION || t.description || '',
+      owner:       t.OWNER       || t.owner       || '',
+      date:        t.DATE        || t.date        || ''
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Create a new transport request.
+ * @param {object} http
+ * @param {string} description
+ * @returns {Promise<string|null>} transport number or null
+ */
+async function createTransport(http, description) {
+  try {
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CREATE', description: description || '' },
+      {}
+    );
+    return result.NUMBER || result.number || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Interactive picker — shown in TTY mode.
+ * Presents a numbered menu; supports scope switching, create, and skip.
+ *
+ * @param {object} http
+ * @returns {Promise<string|null>}
+ */
+async function interactivePicker(http) {
+  const readline = require('readline');
+
+  let scope = 'mine';
+  let transports = [];
+  let fetchError = false;
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+  const fetchAndDisplay = async () => {
+    transports = await fetchTransports(http, scope);
+    fetchError = transports.length === 0;
+
+    const scopeLabel = { mine: 'my transports', task: 'transports where I have a task', all: 'all open transports' }[scope];
+    process.stderr.write(`\nSelect a transport request (showing: ${scopeLabel}):\n\n`);
+
+    if (transports.length > 0) {
+      transports.forEach((t, i) => {
+        process.stderr.write(`  ${i + 1}. ${t.number}  ${t.description}  (${t.owner}, ${t.date})\n`);
+      });
+      process.stderr.write('  ' + '─'.repeat(61) + '\n');
+    } else {
+      if (fetchError) {
+        process.stderr.write('  ⚠️  Could not fetch transports from ABAP system.\n');
+      } else {
+        process.stderr.write('  No open transport requests found.\n');
+      }
+      process.stderr.write('  ' + '─'.repeat(61) + '\n');
+    }
+
+    if (scope !== 'task') process.stderr.write('  s. Show transports where I have a task\n');
+    if (scope !== 'all') process.stderr.write('  a. Show all open transports\n');
+    process.stderr.write('  c. Create new transport request\n');
+    process.stderr.write('  0. Skip (no transport request)\n\n');
+  };
+
+  await fetchAndDisplay();
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const answer = (await ask('Enter number or option: ')).trim().toLowerCase();
+
+    if (answer === '0') {
+      rl.close();
+      return null;
+    }
+
+    if (answer === 's') {
+      scope = 'task';
+      await fetchAndDisplay();
+      continue;
+    }
+
+    if (answer === 'a') {
+      scope = 'all';
+      await fetchAndDisplay();
+      continue;
+    }
+
+    if (answer === 'c') {
+      const desc = (await ask('Description: ')).trim();
+      rl.close();
+      const number = await createTransport(http, desc);
+      if (number) {
+        process.stderr.write(`\n✅ Created transport ${number}\n`);
+        return number;
+      } else {
+        process.stderr.write('\n❌ Could not create transport request.\n');
+        return null;
+      }
+    }
+
+    const idx = parseInt(answer, 10);
+    if (!isNaN(idx) && idx >= 1 && idx <= transports.length) {
+      rl.close();
+      return transports[idx - 1].number;
+    }
+
+    process.stderr.write(`Invalid selection '${answer}'. Enter a number, s, a, c, or 0.\n`);
+  }
+}
+
+/**
+ * Build the `run` helper that is passed to hooks in AI mode.
+ *
+ * run(command) — accepts a full CLI command string, e.g.:
+ *   run('transport list --scope task')
+ *   run('transport create --description "My transport"')
+ *
+ * Splits on whitespace, forces --json, captures output, returns parsed JSON.
+ *
+ * @param {object}   config               - Loaded ABAP config
+ * @param {object}   http                 - Pre-built AbapHttp instance
+ * @param {Function} loadConfig           - Config factory (from pull context)
+ * @param {Function} AbapHttp             - AbapHttp constructor (from pull context)
+ * @param {Function} getTransportSettings - Transport settings getter (from pull context)
+ * @returns {Function|undefined}          - The run helper, or undefined if factories are missing
+ */
+function buildRun(config, http, loadConfig, AbapHttp, getTransportSettings) {
+  if (!loadConfig || !AbapHttp) return undefined;
+
+  return async function run(command) {
+    const [commandName, ...args] = command.trim().split(/\s+/);
+    const cmdModule = require(`../commands/${commandName}`);
+
+    // Always force --json so output is parseable
+    const runArgs = args.includes('--json') ? args : [...args, '--json'];
+
+    // Reuse the already-authenticated http instance
+    const MockAbapHttp = function MockAbapHttp() { return http; };
+
+    const runContext = {
+      loadConfig: () => config,
+      AbapHttp: MockAbapHttp,
+      getTransportSettings: getTransportSettings || (() => ({ allowCreate: true, allowRelease: true, reason: null }))
+    };
+
+    // Capture console.log output; override process.exit to throw instead of exit
+    const captured = [];
+    const origLog = console.log;
+    const origExit = process.exit;
+    console.log = (...a) => captured.push(a.map(String).join(' '));
+    process.exit = (code) => { throw new Error(`process.exit(${code})`); };
+
+    try {
+      await cmdModule.execute(runArgs, runContext);
+    } finally {
+      console.log = origLog;
+      process.exit = origExit;
+    }
+
+    const output = captured.join('');
+    if (!output) throw new Error(`run("${command}") produced no output`);
+    return JSON.parse(output);
+  };
+}
+
+/**
+ * Main export — selects a transport request for use in the pull command.
+ * Returns the transport number, or null to proceed without one.
+ *
+ * @param {object}   config               - Loaded ABAP config
+ * @param {object}   http                 - Pre-built AbapHttp instance
+ * @param {Function} [loadConfig]         - Config factory (enables run helper in hook context)
+ * @param {Function} [AbapHttp]           - AbapHttp constructor (enables run helper in hook context)
+ * @param {Function} [getTransportSettings] - Transport settings getter
+ * @returns {Promise<string|null>}
+ */
+async function selectTransport(config, http, loadConfig, AbapHttp, getTransportSettings) {
+  // Hook takes precedence over the interactive picker — runs in both TTY and non-TTY mode
+  const hookConfig = module.exports._getTransportHookConfig();
+  if (hookConfig && hookConfig.hook) {
+    const hookPath = path.resolve(process.cwd(), hookConfig.hook);
+    const run = buildRun(config, http, loadConfig, AbapHttp, getTransportSettings);
+    try {
+      return await module.exports.runHook(hookPath, { config, http, run });
+    } catch {
+      return null;
+    }
+  }
+
+  // No hook configured — fall back based on context
+  if (isNonInteractive()) {
+    return null;  // AI/CI mode: proceed without transport
+  }
+
+  // Manual mode: interactive picker
+  return interactivePicker(http);
+}
+
+/**
+ * Read transport hook config from .abapgit-agent.json
+ * (mirrors getConflictSettings pattern in config.js)
+ */
+function _getTransportHookConfig() {
+  const fs = require('fs');
+  const projectConfigPath = path.join(process.cwd(), '.abapgit-agent.json');
+
+  if (!fs.existsSync(projectConfigPath)) return null;
+
+  try {
+    const projectConfig = JSON.parse(fs.readFileSync(projectConfigPath, 'utf8'));
+    if (projectConfig && projectConfig.transports?.hook) {
+      return {
+        hook: projectConfig.transports.hook.path || null,
+        description: projectConfig.transports.hook.description || null
+      };
+    }
+  } catch {
+    // ignore parse errors
+  }
+
+  return null;
+}
+
+module.exports = {
+  isNonInteractive,
+  runHook,
+  fetchTransports,
+  createTransport,
+  interactivePicker,
+  selectTransport,
+  buildRun,
+  _getTransportHookConfig
+};