abapgit-agent 1.8.8 → 1.9.0

package/README.md

@@ -144,6 +144,10 @@ abapgit-agent preview --objects SFLIGHT --compact
 abapgit-agent where --objects ZCL_MY_CLASS
 abapgit-agent where --objects ZIF_MY_INTERFACE
 abapgit-agent where --objects ZCL_MY_CLASS --type CLAS
+
+# Query short dumps (ST22)
+abapgit-agent dump --date TODAY
+abapgit-agent dump --user DEVELOPER --date TODAY --detail 1
 ```
 
 ### Utility Commands
@@ -188,6 +192,7 @@ npm run pull -- --url <git-url> --branch main
 | view Command | [docs/view-command.md](docs/view-command.md) |
 | preview Command | [docs/preview-command.md](docs/preview-command.md) |
 | where Command | [docs/where-command.md](docs/where-command.md) |
+| dump Command | [docs/dump-command.md](docs/dump-command.md) |
 | ref Command | [docs/ref-command.md](docs/ref-command.md) |
 | REST API Reference | [API.md](API.md) |
 | Error Handling | [ERROR_HANDLING.md](ERROR_HANDLING.md) |

package/abap/CLAUDE.md

@@ -256,6 +256,110 @@ abapgit-agent unit --files src/zcl_test1.clas.testclasses.abap,src/zcl_test2.cla
 
 ---
 
+### 9. Use `dump` Command to Investigate Runtime Errors (ST22)
+
+**When a user reports an ABAP runtime error, OR when any command returns HTTP 500 / an unexpected ABAP error, proactively check for short dumps.**
+
+```
+❌ WRONG: Ask user to open ST22 transaction manually
+❌ WRONG: Give up after an HTTP 500 without checking what caused it
+✅ CORRECT: Use abapgit-agent dump to query short dumps and find the root cause
+```
+
+#### When to Use `dump`
+
+| Scenario | Action |
+|----------|--------|
+| User reports "there was a dump in production" | `dump --user <user> --date TODAY` |
+| Any command returns HTTP 500 or unexpected error | `dump --date TODAY` (check for recent dumps) |
+| `pull` or `inspect` fails with internal ABAP error | `dump --date TODAY` |
+| Test run fails with runtime error | `dump --program <program> --date TODAY` |
+| Investigating TIME_OUT or other specific error | `dump --error TIME_OUT` |
+| Finding all errors from a specific user | `dump --user DEVELOPER` |
+| Full error analysis with source location | `dump --detail 1` (after listing) |
+
+#### Typical Investigation Workflow
+
+```bash
+# Step 1: List recent dumps (last 7 days by default)
+abapgit-agent dump
+
+# Step 2: Narrow by program or user if known
+abapgit-agent dump --program ZMY_PROGRAM --date TODAY
+
+# Step 3: View full details of the first result
+abapgit-agent dump --program ZMY_PROGRAM --date TODAY --detail 1
+```
+
+The `--detail` output includes:
+- **What happened** — high-level error description
+- **Error analysis** — detailed SAP explanation
+- **Call stack** — method-by-method trace with line numbers
+- **Source with `>>>>>` marker** — exact line where the dump occurred
+
+#### Reading Detail Output
+
+```
+  Short Dump Detail
+
+  Error       MESSAGE_TYPE_X
+  Date        2024-01-15 (Europe/Berlin)
+  Time        09:26:53
+  User        DEVELOPER
+  Program     ZMY_PROGRAM
+
+  What happened:
+  -------------------------------------------------------
+  A RAISE statement raised the exception "MESSAGE_TYPE_X".
+
+  Call stack:
+  -------------------------------------------------------
+    1  ZCL_MY_CLASS->DO_SOMETHING (line 42)
+    2  ZMY_PROGRAM START-OF-SELECTION (line 5)
+
+  Source (ZCL_MY_CLASS=============CM003, line 42):
+  -------------------------------------------------------
+        METHOD do_something.
+          DATA lv_val TYPE i.
+>>>>>     RAISE EXCEPTION TYPE cx_my_error.    ← error here
+          lv_val = lv_val + 1.
+        ENDMETHOD.
+```
+
+**After identifying the error location**, use `view` to understand the class context:
+
+```bash
+# View the class/method where the dump occurred
+abapgit-agent view --objects ZCL_MY_CLASS
+```
+
+#### Filters Reference
+
+```bash
+# Filter by user
+abapgit-agent dump --user DEVELOPER
+
+# Filter by date (system timezone)
+abapgit-agent dump --date TODAY
+abapgit-agent dump --date YESTERDAY
+abapgit-agent dump --date 2024-01-01..2024-01-31
+
+# Filter by program
+abapgit-agent dump --program ZMY_PROGRAM
+
+# Filter by error type
+abapgit-agent dump --error TIME_OUT
+abapgit-agent dump --error MESSAGE_TYPE_X
+
+# Show full detail for result #N (combine with same filters)
+abapgit-agent dump --user DEVELOPER --date TODAY --detail 1
+
+# Use explicit timezone (e.g., for distributed teams)
+abapgit-agent dump --date TODAY --timezone Europe/Berlin
+```
+
+---
+
 ## Development Workflow
 
 This project's workflow mode is configured in `.abapGitAgent` under `workflow.mode`.
@@ -672,6 +776,13 @@ abapgit-agent view --objects ZTABLE --type TABL
 
 # Display package tree
 abapgit-agent tree --package \$MY_PACKAGE
+
+# Investigate runtime errors (ST22 short dumps)
+abapgit-agent dump                                          # Last 7 days
+abapgit-agent dump --user DEVELOPER --date TODAY           # Today's dumps for a user
+abapgit-agent dump --program ZMY_PROGRAM                   # Dumps from a specific program
+abapgit-agent dump --error TIME_OUT                        # Dumps by error type
+abapgit-agent dump --user DEVELOPER --detail 1             # Full detail of first result
 ```
 
 ---

package/bin/abapgit-agent

@@ -50,6 +50,7 @@ async function main() {
     view: require('../src/commands/view'),
     preview: require('../src/commands/preview'),
     where: require('../src/commands/where'),
+    dump: require('../src/commands/dump'),
     ref: require('../src/commands/ref'),
     init: require('../src/commands/init'),
     pull: require('../src/commands/pull'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.8.8",
+  "version": "1.9.0",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [
@@ -33,6 +33,7 @@
     "test:cmd:view": "node tests/run-all.js --cmd --command=view",
     "test:cmd:preview": "node tests/run-all.js --cmd --command=preview",
     "test:cmd:tree": "node tests/run-all.js --cmd --command=tree",
+    "test:cmd:dump": "node tests/run-all.js --cmd --command=dump",
     "test:cmd:upgrade": "node tests/run-all.js --cmd --command=upgrade",
     "test:lifecycle": "node tests/run-all.js --lifecycle",
     "test:pull": "node tests/run-all.js --pull",

package/src/commands/dump.js

@@ -0,0 +1,327 @@
+'use strict';
+
+/**
+ * Dump command - Query short dumps (ST22) from ABAP system
+ */
+
+// Convert a local date/time in the given IANA timezone to a UTC Date.
+// Uses an iterative approach to reliably handle DST transitions.
+function localToUTC(dateStr, timeStr, timezone) {
+  const iso = `${dateStr.slice(0,4)}-${dateStr.slice(4,6)}-${dateStr.slice(6,8)}` +
+              `T${timeStr.slice(0,2)}:${timeStr.slice(2,4)}:${timeStr.slice(4,6)}`;
+  let candidate = new Date(iso + 'Z');
+  for (let i = 0; i < 3; i++) {
+    const localStr = candidate.toLocaleString('sv-SE', { timeZone: timezone }).replace(' ', 'T');
+    const diff = new Date(iso + 'Z').getTime() - new Date(localStr + 'Z').getTime();
+    candidate = new Date(candidate.getTime() + diff);
+  }
+  return candidate;
+}
+
+// Format a UTC Date as a local date/time in the given IANA timezone.
+// Returns { date: 'YYYY-MM-DD', time: 'HH:MM:SS' }.
+function utcToLocal(utcDate, timezone) {
+  const local = utcDate.toLocaleString('sv-SE', { timeZone: timezone });
+  const [date, time] = local.split(' ');
+  return { date, time };
+}
+
+// Parse a 14-char UTC timestamp string (YYYYMMDDhhmmss) to a Date.
+function parseUTCTimestamp(ts) {
+  const s = String(ts).padStart(14, '0');
+  return new Date(`${s.slice(0,4)}-${s.slice(4,6)}-${s.slice(6,8)}T${s.slice(8,10)}:${s.slice(10,12)}:${s.slice(12,14)}Z`);
+}
+
+// Format a UTC Date as a 14-char timestamp string (YYYYMMDDhhmmss).
+function toTimestampStr(date) {
+  return date.toISOString().replace(/[-T:Z]/g, '').slice(0, 14);
+}
+
+// Parse the user's --date argument into { from, to } as YYYYMMDD strings,
+// respecting the given timezone for TODAY/YESTERDAY keywords.
+function parseDateArg(dateStr, timezone) {
+  const nowLocal = utcToLocal(new Date(), timezone);
+  const todayStr = nowLocal.date.replace(/-/g, '');
+
+  const upper = dateStr.toUpperCase();
+  if (upper === 'TODAY') {
+    return { from: todayStr, to: todayStr };
+  }
+  if (upper === 'YESTERDAY') {
+    const d = new Date(nowLocal.date + 'T00:00:00Z');
+    d.setUTCDate(d.getUTCDate() - 1);
+    const yStr = d.toISOString().slice(0, 10).replace(/-/g, '');
+    return { from: yStr, to: yStr };
+  }
+  if (dateStr.includes('..')) {
+    const [a, b] = dateStr.split('..');
+    return { from: a.replace(/-/g, ''), to: b.replace(/-/g, '') };
+  }
+  const d = dateStr.replace(/-/g, '');
+  return { from: d, to: d };
+}
+
+function parseTimeArg(timeStr) {
+  const padTime = (t) => (t.replace(/:/g, '') + '000000').substring(0, 6);
+  if (timeStr.includes('..')) {
+    const [a, b] = timeStr.split('..');
+    return { from: padTime(a), to: padTime(b) };
+  }
+  const t = padTime(timeStr);
+  return { from: t, to: t };
+}
+
+// Resolve display date/time for a dump entry, using utc_timestamp when available.
+function resolveDateTime(dump, timezone) {
+  const ts = dump.UTC_TIMESTAMP || dump.utc_timestamp;
+  if (ts && timezone) {
+    const utcDate = parseUTCTimestamp(ts);
+    return utcToLocal(utcDate, timezone);
+  }
+  return {
+    date: dump.DATE || dump.date || '',
+    time: dump.TIME || dump.time || '',
+  };
+}
+
+function renderList(dumps, total, limit, timezone) {
+  const totalNum = Number(total) || dumps.length;
+  const tzLabel  = timezone ? ` [${timezone}]` : '';
+  console.log(`\n  Short Dumps (${totalNum} found)${tzLabel}\n`);
+
+  if (dumps.length === 0) {
+    console.log('  No short dumps found for the given filters.\n');
+    return;
+  }
+
+  const W = { num: 3, date: 10, time: 8, user: 12, prog: 30, err: 40 };
+  const hdr = `  ${'#'.padStart(W.num)}  ${'Date'.padEnd(W.date)}  ${'Time'.padEnd(W.time)}  ${'User'.padEnd(W.user)}  ${'Program'.padEnd(W.prog)}  Error`;
+  const sep = '  ' + '-'.repeat(W.num + 2 + W.date + 2 + W.time + 2 + W.user + 2 + W.prog + 2 + W.err);
+  console.log(hdr);
+  console.log(sep);
+
+  dumps.forEach((d, i) => {
+    const { date, time } = resolveDateTime(d, timezone);
+    const user = (d.USER || d.user || '').substring(0, W.user);
+    const prog = (d.PROGRAM || d.program || '').substring(0, W.prog);
+    const err  = (d.ERROR || d.error || '');
+    console.log(`  ${String(i + 1).padStart(W.num)}  ${date.padEnd(W.date)}  ${time.padEnd(W.time)}  ${user.padEnd(W.user)}  ${prog.padEnd(W.prog)}  ${err}`);
+  });
+
+  console.log('');
+  if (totalNum > limit) {
+    console.log(`  Showing ${dumps.length} of ${totalNum} dumps. Use --limit to see more.`);
+  }
+  console.log('  Use --detail <number> to see full dump details\n');
+}
+
+function renderDetail(dump, timezone) {
+  console.log('\n  Short Dump Detail\n');
+
+  const { date, time } = resolveDateTime(dump, timezone);
+  const tzLabel = timezone ? ` (${timezone})` : '';
+
+  const fields = [
+    ['Error',     dump.ERROR     || dump.error     || ''],
+    ['Date',      date + tzLabel],
+    ['Time',      time],
+    ['User',      dump.USER      || dump.user      || ''],
+    ['Program',   dump.PROGRAM   || dump.program   || ''],
+    ['Object',    dump.OBJECT    || dump.object    || ''],
+    ['Package',   dump.PACKAGE   || dump.package   || ''],
+    ['Exception', dump.EXCEPTION || dump.exception || ''],
+  ];
+  fields.forEach(([label, val]) => {
+    if (val) {
+      console.log(`  ${label.padEnd(12)}${val}`);
+    }
+  });
+
+  const normalize = (s) => s.replace(/\\n/g, '\n').replace(/\\r/g, '');
+  const whatHappened  = normalize(dump.WHAT_HAPPENED  || dump.what_happened  || '');
+  const errorAnalysis = normalize(dump.ERROR_ANALYSIS || dump.error_analysis || '');
+
+  if (whatHappened) {
+    console.log('\n  What happened:');
+    console.log('  ' + '-'.repeat(55));
+    console.log(whatHappened.split('\n').map(l => '  ' + l).join('\n'));
+  }
+  if (errorAnalysis) {
+    console.log('\n  Error analysis:');
+    console.log('  ' + '-'.repeat(55));
+    console.log(errorAnalysis.split('\n').map(l => '  ' + l).join('\n'));
+  }
+
+  const stack = dump.CALL_STACK || dump.call_stack || [];
+
+  // Separate structured frames (have level) from source block (no level, has raw text)
+  const frames     = stack.filter(f => (f.LEVEL || f.level));
+  const srcEntries = stack.filter(f => !(f.LEVEL || f.level) && (f.METHOD || f.method));
+
+  if (frames.length > 0) {
+    console.log('\n  Call stack:');
+    console.log('  ' + '-'.repeat(55));
+    frames.forEach((frame) => {
+      const level   = frame.LEVEL   || frame.level   || '';
+      const cls     = frame.CLASS   || frame.class   || '';
+      const method  = frame.METHOD  || frame.method  || '';
+      const program = frame.PROGRAM || frame.program || '';
+      const include = frame.INCLUDE || frame.include || '';
+      const line    = frame.LINE    || frame.line    || '';
+      const location = cls ? `${cls}->${method}` : (method ? `${program} ${method}` : program || include);
+      const lineRef  = line ? ` (line ${line})` : '';
+      console.log(`  ${String(level).padStart(3)}  ${location}${lineRef}`);
+    });
+  }
+
+  if (srcEntries.length > 0) {
+    const srcInc  = dump.SOURCE_INCLUDE || dump.source_include || '';
+    const srcLine = dump.SOURCE_LINE    || dump.source_line    || 0;
+    const heading = srcInc ? `  Source (${srcInc}, line ${srcLine}):` : '  Source:';
+    console.log('\n' + heading);
+    console.log('  ' + '-'.repeat(55));
+    const rawText = srcEntries[0].METHOD || srcEntries[0].method || '';
+    console.log(normalize(rawText).split('\n').map(l => '  ' + l).join('\n'));
+  }
+
+  console.log('');
+}
+
+module.exports = {
+  name: 'dump',
+  description: 'Query short dumps (ST22) from ABAP system',
+  requiresAbapConfig: true,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp } = context;
+
+    const idx = (flag) => args.indexOf(flag);
+    const val = (flag) => {
+      const i = idx(flag);
+      return i !== -1 && i + 1 < args.length ? args[i + 1] : null;
+    };
+
+    const userRaw    = val('--user');
+    const dateRaw    = val('--date');
+    const timeRaw    = val('--time');
+    const programRaw = val('--program');
+    const errorRaw   = val('--error');
+    const limitRaw   = val('--limit');
+    const detailRaw  = val('--detail');
+    const timezoneRaw = val('--timezone');
+    const jsonOutput = args.includes('--json');
+
+    const user    = userRaw    ? userRaw.toUpperCase()    : null;
+    const program = programRaw ? programRaw.toUpperCase() : null;
+    const error   = errorRaw   ? errorRaw.toUpperCase()   : null;
+
+    // Resolve timezone: explicit flag > system default
+    const timezone = timezoneRaw || Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+    let limit = 20;
+    if (limitRaw) {
+      const parsed = parseInt(limitRaw, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        limit = Math.min(parsed, 100);
+      }
+    }
+
+    // Build UTC timestamp range from user's date/time in their timezone
+    let tsFrom = null, tsTo = null;
+    if (dateRaw) {
+      const dates = parseDateArg(dateRaw, timezone);
+      const timeF = timeRaw ? parseTimeArg(timeRaw).from : '000000';
+      const timeT = timeRaw ? parseTimeArg(timeRaw).to   : '235959';
+      tsFrom = toTimestampStr(localToUTC(dates.from, timeF, timezone));
+      tsTo   = toTimestampStr(localToUTC(dates.to,   timeT, timezone));
+    } else if (timeRaw) {
+      // Time filter without date: apply to the default 7-day window
+      const now    = utcToLocal(new Date(), timezone);
+      const today  = now.date.replace(/-/g, '');
+      const sevenAgo = (() => {
+        const d = new Date(now.date + 'T00:00:00Z');
+        d.setUTCDate(d.getUTCDate() - 7);
+        return d.toISOString().slice(0, 10).replace(/-/g, '');
+      })();
+      const times = parseTimeArg(timeRaw);
+      tsFrom = toTimestampStr(localToUTC(sevenAgo, times.from, timezone));
+      tsTo   = toTimestampStr(localToUTC(today,    times.to,   timezone));
+    }
+
+    const detailN = detailRaw ? parseInt(detailRaw, 10) : null;
+
+    const config = loadConfig();
+    const http   = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const buildData = (extra) => {
+      const data = { limit };
+      if (user)    data.user    = user;
+      if (program) data.program = program;
+      if (error)   data.error   = error;
+      if (tsFrom) {
+        data.ts_from = tsFrom;
+        data.ts_to   = tsTo;
+      }
+      return Object.assign(data, extra);
+    };
+
+    if (detailN) {
+      // Two-step: first list (using limit 100 to get full page), then detail
+      const listResult = await http.post('/sap/bc/z_abapgit_agent/dump', buildData({ limit: 100 }), { csrfToken });
+      const listSuccess = listResult.SUCCESS || listResult.success;
+      const listErr     = listResult.ERROR   || listResult.error;
+
+      if (!listSuccess || listErr) {
+        console.error(`\n  Error: ${listErr || 'Failed to query short dumps'}\n`);
+        return;
+      }
+
+      const dumps = listResult.DUMPS || listResult.dumps || [];
+      if (detailN < 1 || detailN > dumps.length) {
+        console.error(`\n  Error: Row number ${detailN} not found in results (found ${dumps.length} dump(s))\n`);
+        return;
+      }
+
+      const targetId = dumps[detailN - 1].ID || dumps[detailN - 1].id;
+      const detailResult = await http.post('/sap/bc/z_abapgit_agent/dump', buildData({ detail: targetId }), { csrfToken });
+
+      const success = detailResult.SUCCESS || detailResult.success;
+      const errMsg  = detailResult.ERROR   || detailResult.error;
+
+      if (!success || errMsg) {
+        console.error(`\n  Error: ${errMsg || 'Failed to load dump detail'}\n`);
+        return;
+      }
+
+      if (jsonOutput) {
+        console.log(JSON.stringify(detailResult, null, 2));
+        return;
+      }
+
+      const detailDumps = detailResult.DUMPS || detailResult.dumps || [];
+      renderDetail(detailDumps[0] || {}, timezone);
+      return;
+    }
+
+    // List mode
+    const result  = await http.post('/sap/bc/z_abapgit_agent/dump', buildData({}), { csrfToken });
+    const success = result.SUCCESS || result.success;
+    const errMsg  = result.ERROR   || result.error;
+
+    if (!success || errMsg) {
+      console.error(`\n  Error: ${errMsg || 'Failed to query short dumps'}\n`);
+      return;
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const dumps = result.DUMPS  || result.dumps  || [];
+    const total = result.TOTAL  || result.total  || dumps.length;
+    renderList(dumps, total, limit, timezone);
+  }
+};

package/src/commands/help.js

@@ -58,6 +58,9 @@ Commands:
   where --objects <obj1>,<obj2>,... [--type <type>] [--limit <n>] [--json]
     Find where-used list for ABAP objects (classes, interfaces, programs)
 
+  dump [--user <user>] [--date <date>] [--time <HH:MM..HH:MM>] [--timezone <tz>] [--program <prog>] [--error <error>] [--limit <n>] [--detail <n>] [--json]
+    Query short dumps (ST22) from ABAP system. Use --detail <n> to view full details.
+
   ref <pattern> [--json]
     Search ABAP reference repositories for patterns. Requires referenceFolder in .abapGitAgent.
 
@@ -100,12 +103,14 @@ Examples:
   abapgit-agent list --package $MY_PACKAGE --type CLAS,INTF  # List classes & interfaces
   abapgit-agent view --objects ZCL_MY_CLASS                  # View class definition
   abapgit-agent where --objects ZCL_MY_CLASS                 # Find where class is used
+  abapgit-agent dump --date TODAY                            # Recent short dumps
+  abapgit-agent dump --user DEVELOPER --detail 1             # Full detail of first result
   abapgit-agent ref "CORRESPONDING"                          # Search for pattern
   abapgit-agent ref --topic exceptions                       # View exceptions topic
   abapgit-agent health                                       # Health check
   abapgit-agent status                                       # Configuration status
 
-For more info: https://github.tools.sap/I045696/abapgit-agent
+For more info: https://github.com/SylvosCai/abapgit-agent
 `);
   }
 };

package/src/commands/pull.js

@@ -77,7 +77,7 @@ module.exports = {
     await this.pull(gitUrl, branch, files, transportRequest, loadConfig, AbapHttp, jsonOutput);
   },
 
-  async pull(gitUrl, branch = 'main', files = null, transportRequest = null, loadConfig, AbapHttp, jsonOutput = false) {
+  async pull(gitUrl, branch = 'main', files = null, transportRequest = null, loadConfig, AbapHttp, jsonOutput = false, gitCredentials = undefined) {
     const TERM_WIDTH = process.stdout.columns || 80;
 
     if (!jsonOutput) {
@@ -99,11 +99,15 @@ module.exports = {
       const csrfToken = await http.fetchCsrfToken();
 
       // Prepare request data with git credentials
+      // gitCredentials=null means no credentials (public repo); undefined means use config defaults
+      const resolvedCredentials = gitCredentials === undefined
+        ? { username: config.gitUsername, password: config.gitPassword }
+        : gitCredentials;
+
       const data = {
         url: gitUrl,
         branch: branch,
-        username: config.gitUsername,
-        password: config.gitPassword
+        ...(resolvedCredentials ? { username: resolvedCredentials.username, password: resolvedCredentials.password } : {})
       };
 
       // Add files array if specified
@@ -198,9 +202,9 @@ module.exports = {
         console.log(`   Job ID: ${jobId || 'N/A'}`);
         console.log(`   Message: ${message || 'N/A'}`);
       } else {
-        console.log(`❌ Pull completed with errors!`);
-        console.log(`   Job ID: ${jobId || 'N/A'}`);
-        console.log(`   Message: ${message || 'N/A'}`);
+        console.error(`❌ Pull completed with errors!`);
+        console.error(`   Job ID: ${jobId || 'N/A'}`);
+        console.error(`   Message: ${message || 'N/A'}`);
       }
 
       // Display error detail if available
@@ -306,8 +310,18 @@ module.exports = {
         console.log(`\n❌ Failed Objects Log (${failedCount})`);
       }
 
+      // Throw if pull was not successful so callers (e.g. upgrade) can detect failure
+      if (success !== 'X' && success !== true) {
+        const err = new Error(message || 'Pull completed with errors');
+        err._isPullError = true;
+        throw err;
+      }
+
       return result;
     } catch (error) {
+      if (error._isPullError) {
+        throw error;
+      }
       console.error(`\n❌ Error: ${error.message}`);
       process.exit(1);
     }

package/src/commands/upgrade.js

@@ -46,10 +46,29 @@ module.exports = {
         const { apiVersion } = await versionCheck.checkCompatibility(config);
         abapVersion = apiVersion;
       } catch (e) {
-        console.error(`⚠️  Could not fetch ABAP version: ${e.message}`);
+        console.error(`⚠️  Could not reach ABAP system: ${e.message}`);
       }
     }
 
+    // If ABAP is unreachable and we need to upgrade it, warn and ask whether to continue CLI-only
+    if (needsAbapConfig && abapVersion === null && !flags.cliOnly && !flags.abapOnly && !flags.match) {
+      console.error('');
+      console.error('⚠️  ABAP system is unreachable. Cannot upgrade ABAP backend.');
+      if (flags.yes) {
+        console.log('   --yes flag set: upgrading CLI only.');
+        flags.cliOnly = true;
+      } else {
+        const proceed = await this.confirmCliOnlyFallback();
+        if (!proceed) {
+          console.log('Upgrade cancelled.');
+          return;
+        }
+        flags.cliOnly = true;
+      }
+      console.log('   Run "abapgit-agent upgrade --abap-only" once the system is back.');
+      console.log('');
+    }
+
     // Get latest version from npm
     const latestVersion = await versionCheck.getLatestNpmVersion();
     if (!latestVersion && !flags.version && !flags.match) {
@@ -260,8 +279,8 @@ module.exports = {
       step++;
     }
     if (targets.abapTarget) {
-      console.log(`  ${step}. abapgit-agent pull --branch v${targets.abapTarget}`);
-      console.log('     (via existing abapGit repository)');
+      console.log(`  ${step}. abapgit-agent pull --url <agentRepoUrl> --branch v${targets.abapTarget}`);
+      console.log('     (agentRepoUrl from .abapGitAgent config or current git remote)');
       step++;
     }
     console.log(`  ${step}. Verify versions match`);
@@ -379,7 +398,24 @@ module.exports = {
   },
 
   /**
-   * Upgrade ABAP backend via pull command
+   * Confirm CLI-only fallback when ABAP system is unreachable
+   */
+  async confirmCliOnlyFallback() {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      rl.question('   Continue with CLI upgrade only? [Y/n] ', (answer) => {
+        rl.close();
+        const normalized = answer.trim().toLowerCase();
+        resolve(normalized === '' || normalized === 'y' || normalized === 'yes');
+      });
+    });
+  },
+
+  /**
    */
   async upgradeAbapBackend(version, transport, context) {
     console.log(`📦 Upgrading ABAP backend to v${version}...`);
@@ -387,15 +423,20 @@ module.exports = {
     console.log('');
 
     try {
-      // Build pull command args
-      const pullArgs = ['--branch', `v${version}`];
-      if (transport) {
-        pullArgs.push('--transport', transport);
-      }
+      const { loadConfig } = context;
+
+      // Determine the abapgit-agent repository URL.
+      // Priority:
+      //   1. agentRepoUrl from .abapGitAgent config (for forks/mirrors)
+      //   2. Default canonical repository
+      const config = loadConfig();
+      const agentRepoUrl = config.agentRepoUrl || 'https://github.com/SylvosCai/abapgit-agent.git';
 
-      // Execute pull command
+      // Execute pull command — pass null credentials so the canonical
+      // public GitHub repo is not sent the project's SAP internal git credentials.
       const pullCommand = require('./pull');
-      await pullCommand.execute(pullArgs, context);
+      const { loadConfig: lc, AbapHttp } = context;
+      await pullCommand.pull(agentRepoUrl, `v${version}`, null, transport || null, lc, AbapHttp, false, null);
 
       console.log('');
       console.log(`✅ ABAP backend upgraded to v${version}`);
@@ -404,9 +445,13 @@ module.exports = {
       console.error(`❌ Failed to upgrade ABAP backend: ${error.message}`);
       console.error('');
       console.error('This may be due to:');
+      console.error('  - ABAP system is unavailable');
       console.error('  - Git tag not found in repository');
       console.error('  - ABAP activation errors');
       console.error('  - Connection issues with ABAP system');
+      console.error('');
+      console.error('To retry once the system is available:');
+      console.error(`  abapgit-agent upgrade --abap-only --version ${version}`);
       process.exit(1);
     }
   },

package/src/utils/version-check.js

@@ -75,9 +75,9 @@ async function checkCompatibility(config) {
             const apiVersion = result.version || '1.0.0';
 
             if (cliVersion !== apiVersion) {
-              console.log(`\n⚠️  Version mismatch: CLI ${cliVersion}, ABAP API ${apiVersion}`);
-              console.log('   Some commands may not work correctly.');
-              console.log('   Update ABAP code: abapgit-agent pull\n');
+              console.error(`\n⚠️  Version mismatch: CLI ${cliVersion}, ABAP API ${apiVersion}`);
+              console.error('   Some commands may not work correctly.');
+              console.error('   Update ABAP code: abapgit-agent upgrade --match\n');
             }
             resolve({ cliVersion, apiVersion, compatible: cliVersion === apiVersion });
           } catch (e) {
@@ -242,9 +242,9 @@ async function showNewVersionReminder() {
     const { hasNewVersion, latestVersion, currentVersion } = await checkForNewVersion();
 
     if (hasNewVersion) {
-      console.log('');
-      console.log(`💡 New version available: ${latestVersion} (current: ${currentVersion})`);
-      console.log(`   Run: abapgit-agent upgrade`);
+      console.error('');
+      console.error(`💡 New version available: ${latestVersion} (current: ${currentVersion})`);
+      console.error(`   Run: abapgit-agent upgrade`);
     }
   } catch (e) {
     // Silent - don't interrupt user's workflow