abapgit-agent 1.10.0 → 1.11.0

package/src/commands/transport.js

@@ -0,0 +1,290 @@
+/**
+ * Transport command - List and manage SAP transport requests
+ */
+
+const VALID_SCOPES = ['mine', 'task', 'all'];
+const VALID_SUBCOMMANDS = ['list', 'create', 'check', 'release'];
+const VALID_TYPES = ['workbench', 'customizing'];
+
+module.exports = {
+  name: 'transport',
+  description: 'List and manage SAP transport requests',
+  requiresAbapConfig: true,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, getTransportSettings } = context;
+
+    const jsonOutput = args.includes('--json');
+
+    // Determine subcommand (first positional arg, default to 'list')
+    const subcommand = args[0] && !args[0].startsWith('-') ? args[0] : 'list';
+
+    if (!VALID_SUBCOMMANDS.includes(subcommand)) {
+      console.error(`❌ Error: Unknown subcommand '${subcommand}'. Use: ${VALID_SUBCOMMANDS.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Check project-level transport settings
+    const transportSettings = getTransportSettings();
+
+    if (subcommand === 'create' && !transportSettings.allowCreate) {
+      console.error(`❌ transport create is disabled for this project.`);
+      if (transportSettings.reason) console.error(`   Reason: ${transportSettings.reason}`);
+      console.error(`   This safeguard is configured in .abapgit-agent.json`);
+      const err = new Error('transport create disabled');
+      err._isTransportError = true;
+      throw err;
+    }
+
+    if (subcommand === 'release' && !transportSettings.allowRelease) {
+      console.error(`❌ transport release is disabled for this project.`);
+      if (transportSettings.reason) console.error(`   Reason: ${transportSettings.reason}`);
+      console.error(`   This safeguard is configured in .abapgit-agent.json`);
+      const err = new Error('transport release disabled');
+      err._isTransportError = true;
+      throw err;
+    }
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+
+    try {
+      switch (subcommand) {
+        case 'list':
+          await this._list(args, http, jsonOutput);
+          break;
+        case 'create':
+          await this._create(args, http, jsonOutput);
+          break;
+        case 'check':
+          await this._check(args, http, jsonOutput);
+          break;
+        case 'release':
+          await this._release(args, http, jsonOutput);
+          break;
+      }
+    } catch (error) {
+      console.error(`❌ Error: ${error.message}`);
+      process.exit(1);
+    }
+  },
+
+  async _list(args, http, jsonOutput) {
+    const scopeIdx = args.indexOf('--scope');
+    const scope = scopeIdx !== -1 ? args[scopeIdx + 1] : 'mine';
+
+    if (!VALID_SCOPES.includes(scope)) {
+      console.error(`❌ Error: Invalid scope '${scope}'. Valid values: ${VALID_SCOPES.join(', ')}`);
+      process.exit(1);
+    }
+
+    const result = await http.get(`/sap/bc/z_abapgit_agent/transport?scope=${scope}`);
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const transports = result.TRANSPORTS || result.transports || [];
+    const scopeLabel = { mine: 'mine', task: 'task — where I own or have a task', all: 'all' }[scope];
+
+    console.log(`\n📋 Open Transport Requests (${scopeLabel})\n`);
+
+    if (transports.length === 0) {
+      console.log('  No open transport requests found.');
+      console.log('');
+      console.log('  To create one: abapgit-agent transport create');
+      console.log('  To see more:   abapgit-agent transport list --scope task');
+      return;
+    }
+
+    // Table header
+    const numW = 2;
+    const trW = 12;
+    const descW = 33;
+    const ownerW = 12;
+    const dateW = 10;
+
+    const pad = (s, w) => String(s || '').substring(0, w).padEnd(w);
+    const header = `  ${'#'.padEnd(numW)}  ${pad('Number', trW)}  ${pad('Description', descW)}  ${pad('Owner', ownerW)}  ${'Date'}`;
+    const divider = `  ${'─'.repeat(numW)}  ${'─'.repeat(trW)}  ${'─'.repeat(descW)}  ${'─'.repeat(ownerW)}  ${'─'.repeat(dateW)}`;
+
+    console.log(header);
+    console.log(divider);
+
+    transports.forEach((t, i) => {
+      const num = t.NUMBER || t.number || '';
+      const desc = t.DESCRIPTION || t.description || '';
+      const owner = t.OWNER || t.owner || '';
+      const date = t.DATE || t.date || '';
+      console.log(`  ${String(i + 1).padEnd(numW)}  ${pad(num, trW)}  ${pad(desc, descW)}  ${pad(owner, ownerW)}  ${date}`);
+    });
+
+    console.log('');
+    console.log(`  ${transports.length} transport(s) found.`);
+    console.log('');
+    console.log(`  To use one: abapgit-agent pull --transport ${(transports[0].NUMBER || transports[0].number || 'DEVK900001')}`);
+
+    if (scope === 'mine') {
+      console.log('  To switch scope:');
+      console.log('    transport list --scope task   transports where I have a task');
+      console.log('    transport list --scope all     all open transports');
+    }
+  },
+
+  async _create(args, http, jsonOutput) {
+    const descIdx = args.indexOf('--description');
+    let description = descIdx !== -1 ? args[descIdx + 1] : null;
+
+    const typeIdx = args.indexOf('--type');
+    const type = typeIdx !== -1 ? args[typeIdx + 1] : 'workbench';
+
+    if (!VALID_TYPES.includes(type)) {
+      console.error(`❌ Error: Invalid type '${type}'. Valid values: ${VALID_TYPES.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Prompt for description if not provided and running in TTY
+    if (!description && !jsonOutput && process.stdin.isTTY) {
+      description = await this._prompt('Description: ');
+    }
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CREATE', description: description || '', type },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const number = result.NUMBER || result.number;
+    const success = result.SUCCESS === true || result.success === true ||
+                    result.SUCCESS === 'X' || result.success === 'X';
+    const typeLabel = type === 'customizing' ? 'Customizing' : 'Workbench';
+
+    if (success && number) {
+      console.log(`\n✅ Transport ${number} created (${typeLabel} request).\n`);
+      console.log(`   To use it now: abapgit-agent pull --transport ${number}`);
+    } else {
+      const error = result.ERROR || result.error || result.MESSAGE || result.message || 'Could not create transport request';
+      console.error(`❌ Error: ${error}`);
+      process.exit(1);
+    }
+  },
+
+  async _check(args, http, jsonOutput) {
+    const numIdx = args.indexOf('--number');
+    if (numIdx === -1 || !args[numIdx + 1]) {
+      console.error('❌ Error: --number is required for transport check');
+      process.exit(1);
+    }
+    const number = args[numIdx + 1];
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CHECK', number },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const passed = result.PASSED === true || result.passed === true ||
+                   result.PASSED === 'X' || result.passed === 'X';
+    const issues = result.ISSUES || result.issues || [];
+    const desc = result.DESCRIPTION || result.description || '';
+    const owner = result.OWNER || result.owner || '';
+    const date = result.DATE || result.date || '';
+
+    console.log(`\n🔍 Checking transport ${number}...`);
+    if (desc) console.log(`\n   Description: ${desc}`);
+    if (owner) console.log(`   Owner: ${owner}`);
+    if (date) console.log(`   Date: ${date}`);
+
+    if (passed || issues.length === 0) {
+      console.log(`\n✅ Transport check passed — no issues found.`);
+      console.log(`   Ready to release: abapgit-agent transport release --number ${number}`);
+    } else {
+      console.log(`\n⚠️  Transport check completed with warnings/errors:\n`);
+
+      const typeW = 6;
+      const objW = 21;
+      const msgW = 44;
+      const pad = (s, w) => String(s || '').substring(0, w).padEnd(w);
+
+      console.log(`  ${'Type'.padEnd(typeW)}  ${'Object'.padEnd(objW)}  Message`);
+      console.log(`  ${'─'.repeat(typeW)}  ${'─'.repeat(objW)}  ${'─'.repeat(msgW)}`);
+
+      for (const issue of issues) {
+        const type = issue.TYPE || issue.type || '';
+        const objType = issue.OBJ_TYPE || issue.obj_type || '';
+        const objName = issue.OBJ_NAME || issue.obj_name || '';
+        const text = issue.TEXT || issue.text || '';
+        const icon = type === 'E' ? '❌' : type === 'W' ? '⚠️ ' : 'ℹ️ ';
+        const obj = objType && objName ? `${objType} ${objName}` : objType || objName;
+        console.log(`  ${icon.padEnd(typeW)}  ${pad(obj, objW)}  ${text}`);
+      }
+
+      console.log(`\n  ${issues.length} issue(s) found. Fix before releasing.`);
+    }
+  },
+
+  async _release(args, http, jsonOutput) {
+    const numIdx = args.indexOf('--number');
+    if (numIdx === -1 || !args[numIdx + 1]) {
+      console.error('❌ Error: --number is required for transport release');
+      process.exit(1);
+    }
+    const number = args[numIdx + 1];
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'RELEASE', number },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const success = result.SUCCESS === true || result.success === true ||
+                    result.SUCCESS === 'X' || result.success === 'X';
+    const message = result.MESSAGE || result.message || '';
+    const error = result.ERROR || result.error || '';
+    const desc = result.DESCRIPTION || result.description || '';
+
+    if (success) {
+      console.log(`\n🚀 Releasing transport ${number}...`);
+      if (desc) console.log(`\n   Description: ${desc}`);
+      console.log(`\n✅ Transport ${number} released successfully.`);
+    } else {
+      console.error(`\n❌ Could not release transport ${number}.`);
+      if (error) {
+        console.error(`\n   Error: ${error}`);
+      } else if (message) {
+        console.error(`\n   Error: ${message}`);
+      }
+    }
+  },
+
+  _prompt(question) {
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+};

package/src/config.js

@@ -141,6 +141,62 @@ function getProjectInfo() {
   return projectConfig?.project || null;
 }
 
+/**
+ * Get conflict detection configuration from project-level config
+ * Precedence: CLI flag > project config > default ('abort')
+ * @returns {Object} Conflict detection config with mode and reason
+ */
+function getConflictSettings() {
+  const projectConfig = loadProjectConfig();
+
+  if (projectConfig?.conflictDetection) {
+    const validModes = ['ignore', 'abort'];
+    const mode = projectConfig.conflictDetection.mode;
+    if (mode && !validModes.includes(mode)) {
+      console.warn(`⚠️  Warning: Invalid conflictDetection.mode '${mode}' in .abapgit-agent.json. Must be one of: ${validModes.join(', ')}. Falling back to 'abort'.`);
+      return { mode: 'abort', reason: null };
+    }
+    return {
+      mode: mode || 'abort',
+      reason: projectConfig.conflictDetection.reason || null
+    };
+  }
+
+  // Default: abort (conflict detection on by default)
+  return { mode: 'abort', reason: null };
+}
+
+/**
+ * Get transport hook configuration from project-level config
+ * @returns {{ hook: string|null, description: string|null }}
+ */
+function getTransportHookConfig() {
+  const projectConfig = loadProjectConfig();
+  if (projectConfig?.transports?.hook) {
+    return {
+      hook: projectConfig.transports.hook.path || null,
+      description: projectConfig.transports.hook.description || null
+    };
+  }
+  return { hook: null, description: null };
+}
+
+/**
+ * Get transport operation settings from project-level config
+ * @returns {{ allowCreate: boolean, allowRelease: boolean, reason: string|null }}
+ */
+function getTransportSettings() {
+  const projectConfig = loadProjectConfig();
+  if (projectConfig?.transports) {
+    return {
+      allowCreate:  projectConfig.transports.allowCreate  !== false,
+      allowRelease: projectConfig.transports.allowRelease !== false,
+      reason:       projectConfig.transports.reason || null
+    };
+  }
+  return { allowCreate: true, allowRelease: true, reason: null };
+}
+
 module.exports = {
   loadConfig,
   getAbapConfig,
@@ -150,5 +206,8 @@ module.exports = {
   getWorkflowConfig,
   getSafeguards,
   getProjectInfo,
-  loadProjectConfig
+  getConflictSettings,
+  loadProjectConfig,
+  getTransportHookConfig,
+  getTransportSettings
 };

package/src/utils/adt-http.js

@@ -199,12 +199,37 @@ class AdtHttp {
           return;
         }
 
-        // Update cookies from any response that sets them
+        // Update cookies from any response that sets them.
+        // Merge by name so that updated values (e.g. SAP_SESSIONID) replace
+        // their old counterparts rather than accumulating duplicates.
+        // Duplicate SAP_SESSIONID cookies would cause the ICM to route requests
+        // to a stale work process ("Service cannot be reached").
         if (res.headers['set-cookie']) {
-          const newCookies = Array.isArray(res.headers['set-cookie'])
-            ? res.headers['set-cookie'].map(c => c.split(';')[0]).join('; ')
-            : res.headers['set-cookie'].split(';')[0];
-          this.cookies = this.cookies ? this.cookies + '; ' + newCookies : newCookies;
+          const incoming = Array.isArray(res.headers['set-cookie'])
+            ? res.headers['set-cookie'].map(c => c.split(';')[0])
+            : [res.headers['set-cookie'].split(';')[0]];
+          // Parse existing cookies into a Map (preserves insertion order)
+          const jar = new Map();
+          if (this.cookies) {
+            this.cookies.split(';').forEach(pair => {
+              const trimmed = pair.trim();
+              if (trimmed) {
+                const eq = trimmed.indexOf('=');
+                const k = eq === -1 ? trimmed : trimmed.slice(0, eq);
+                jar.set(k.trim(), trimmed);
+              }
+            });
+          }
+          // Overwrite with incoming cookies
+          incoming.forEach(pair => {
+            const trimmed = pair.trim();
+            if (trimmed) {
+              const eq = trimmed.indexOf('=');
+              const k = eq === -1 ? trimmed : trimmed.slice(0, eq);
+              jar.set(k.trim(), trimmed);
+            }
+          });
+          this.cookies = [...jar.values()].join('; ');
         }
 
         let respBody = '';

package/src/utils/debug-daemon.js

@@ -67,6 +67,17 @@ async function startDaemon(config, sessionId, socketPath, snapshot) {
 
   const session = new DebugSession(adt, sessionId);
 
+  // Pin the SAP_SESSIONID so _restorePinnedSession() works inside the daemon.
+  // DebugSession.attach() normally sets pinnedSessionId, but the daemon skips
+  // attach() and reconstructs the session from the snapshot.  Without this,
+  // any CSRF refresh that AdtHttp performs internally (401/403 retry → HEAD
+  // request → new Set-Cookie) silently overwrites the session cookie and routes
+  // subsequent IPC calls to the wrong ABAP work process → HTTP 400.
+  if (snapshot && snapshot.cookies) {
+    const m = snapshot.cookies.match(/SAP_SESSIONID=([^;]*)/);
+    if (m) session.pinnedSessionId = m[1];
+  }
+
   // Remove stale socket file from a previous crash
   try { fs.unlinkSync(socketPath); } catch (e) { /* ignore ENOENT */ }
 
@@ -85,6 +96,17 @@ async function startDaemon(config, sessionId, socketPath, snapshot) {
     process.exit(code || 0);
   }
 
+  // On SIGTERM (e.g. pkill from ensure_breakpoint cleanup), attempt to release
+  // the frozen ABAP work process before exiting.  Without this, killing the
+  // daemon leaves the work process paused at the breakpoint until SAP's own
+  // session-timeout fires (up to several minutes).
+  process.once('SIGTERM', async () => {
+    try {
+      await session.terminate();
+    } catch (e) { /* ignore — best effort */ }
+    cleanupAndExit(0);
+  });
+
   const server = net.createServer((socket) => {
     resetIdle();
     let buf = '';
@@ -170,7 +192,8 @@ async function _handleLine(socket, line, session, cleanupAndExit, resetIdle) {
     _send(socket, {
       ok: false,
       error: err.message || JSON.stringify(err),
-      statusCode: err.statusCode
+      statusCode: err.statusCode,
+      body: err.body || null
     });
   }
 }

package/src/utils/debug-repl.js

@@ -76,6 +76,11 @@ async function startRepl(session, initialState, onBeforeExit) {
 
   renderState(position, source, variables);
 
+  // Keep the ADT stateful session alive with periodic getStack() pings.
+  // SAP's ICM drops session affinity after ~60 s of idle, causing stepContinue
+  // to route to the wrong work process (HTTP 400) when the user eventually quits.
+  session.startKeepalive();
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -178,6 +183,7 @@ async function startRepl(session, initialState, onBeforeExit) {
 
       } else if (cmd === 'q' || cmd === 'quit') {
         console.log('\n  Detaching debugger — program will continue running...');
+        session.stopKeepalive();
         try {
           await session.detach();
         } catch (e) {
@@ -190,6 +196,7 @@ async function startRepl(session, initialState, onBeforeExit) {
 
       } else if (cmd === 'kill') {
         console.log('\n  Terminating program (hard abort)...');
+        session.stopKeepalive();
         try {
           await session.terminate();
         } catch (e) {
@@ -213,7 +220,23 @@ async function startRepl(session, initialState, onBeforeExit) {
   });
 
   rl.on('close', async () => {
+    // stdin closed (EOF or Ctrl+D) without an explicit 'q' or 'kill' command.
+    // Detach so the ABAP work process is released — without this the WP stays
+    // frozen in SM50 (e.g. when attach is started with </dev/null stdin and
+    // readline gets immediate EOF before the user can type a command).
+    if (!exitCleanupDone) {
+      session.stopKeepalive();
+      try { await session.detach(); } catch (e) { /* ignore */ }
+    }
     await runExitCleanup();
+    // Drain stdout/stderr before exiting so the OS TCP stack has flushed the
+    // outbound stepContinue request bytes. process.exit() tears down file
+    // descriptors immediately — without this the WP can stay frozen if the
+    // socket buffer hasn't been written to the NIC yet.
+    await new Promise(resolve => {
+      if (process.stdout.writableEnded) return resolve();
+      process.stdout.write('', resolve);
+    });
     process.exit(0);
   });