abap-local-client 1.4.2 → 1.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abap-local-client",
-  "version": "1.4.2",
+  "version": "1.4.5",
   "description": "SAP Local Client — WebSocket bridge with Basic, SPNEGO, X.509, SAML & SNC authentication",
   "main": "sso-sap-client.mjs",
   "type": "module",

package/sso-sap-client.mjs

@@ -269,6 +269,36 @@ async function handleHttpCall(callspec, httpsAgent) {
         request_url_resolved: callspec.path.startsWith('http') ? callspec.path : `${sysCfg.baseUrl}${callspec.path.split('?')[0]}`, error: null }));
 }
 
+// ════════════════════════════════════════════════════════════════════════════
+// ADT URL helper
+// ════════════════════════════════════════════════════════════════════════════
+
+const ADT_TYPE_PATHS = {
+  CLAS: '/sap/bc/adt/oo/classes',
+  CLASS: '/sap/bc/adt/oo/classes',
+  INTF: '/sap/bc/adt/oo/interfaces',
+  INTERFACE: '/sap/bc/adt/oo/interfaces',
+  PROG: '/sap/bc/adt/programs/programs',
+  REPORT: '/sap/bc/adt/programs/programs',
+  INCL: '/sap/bc/adt/programs/includes',
+  INCLUDE: '/sap/bc/adt/programs/includes',
+  TABL: '/sap/bc/adt/ddic/tables',
+  TABLE: '/sap/bc/adt/ddic/tables',
+  STRU: '/sap/bc/adt/ddic/structures',
+  DDLS: '/sap/bc/adt/ddic/ddl/sources',
+  CDS: '/sap/bc/adt/ddic/ddl/sources',
+  BDEF: '/sap/bc/adt/bo/behaviordefinitions',
+  SRVD: '/sap/bc/adt/bo/servicedefinitions',
+  SRVB: '/sap/bc/adt/bo/servicebindings',
+  FUNC: '/sap/bc/adt/functions/groups',
+};
+
+function buildAdtUnlockUrl(name, type, lockHandle) {
+  const basePath = ADT_TYPE_PATHS[type?.toUpperCase()];
+  if (!basePath) return null;
+  return `${basePath}/${name.toUpperCase()}?_action=UNLOCK&lockHandle=${encodeURIComponent(lockHandle)}`;
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // Lock Manager — IDENTICAL to websocket-client.js
 // ════════════════════════════════════════════════════════════════════════════
@@ -288,6 +318,7 @@ class LockManager {
   }
   clearLock(objectName, objectType) { this.locks.delete(`${objectName.toUpperCase()}:${objectType.toUpperCase()}`); }
   clearAll() { const c = this.locks.size; this.locks.clear(); if (c > 0) console.log(`   🧹 All locks cleared (${c} lock(s))`); }
+  getAll() { return Array.from(this.locks.entries()).map(([key, lock]) => { const [name, type] = key.split(':'); return { name, type, ...lock }; }); }
   getStats() { return { activeLocks: this.locks.size, locks: Array.from(this.locks.keys()) }; }
 }
 
@@ -658,6 +689,7 @@ class WebSocketClient {
         if (!sys) { this.sendResponse(requestId, false, { error: `Unknown system: ${sid}` }); return; }
         this.currentSystemId = sid;
         this.lockManager.clearAll();
+        sessions.delete(sid);  // force re-create session with fresh config on every switch
         const ok = await this.initSapClient();
         if (!ok) { this.sendResponse(requestId, false, { error: `Failed to connect to ${sid}. Check RFC/SNC config and logs.` }); return; }
         this.sendResponse(requestId, true, [{ success: true, data: { system: sid, authMode: sys.authMode } }]);
@@ -726,6 +758,41 @@ class WebSocketClient {
       }
       for (let i = 0; i < callspecs.length; i++) {
         const cs = callspecs[i];
+
+        // ── Special client-side commands ────────────────────────────────────
+        if (cs.command) {
+          if (cs.command === 'unlock_all') {
+            console.log(`\n   📋 Step: unlock_all (client-side)`);
+            const allLocks = this.lockManager.getAll();
+            console.log(`   🔓 Unlocking ${allLocks.length} cached lock(s)...`);
+            let unlocked = 0, failed = 0;
+            for (const lock of allLocks) {
+              const unlockUrl = buildAdtUnlockUrl(lock.name, lock.type, lock.lockHandle);
+              if (!unlockUrl) { console.log(`   ⚠️  No ADT path for type ${lock.type} — skipping`); failed++; continue; }
+              const r = await this.sapClient.executeCallspec({ method: 'DELETE', url: unlockUrl, headers: {} });
+              if (r.success) { this.lockManager.clearLock(lock.name, lock.type); unlocked++; console.log(`   ✅ Unlocked ${lock.type}:${lock.name}`); }
+              else { failed++; console.log(`   ⚠️  Failed to unlock ${lock.type}:${lock.name}: ${r.error || r.status}`); }
+            }
+            results.push({ success: true, status: 200, data: { unlocked, failed, total: allLocks.length } });
+            continue;
+          }
+          if (cs.command === 'force_unlock') {
+            const { objectName, objectType, lockHandle } = cs;
+            console.log(`\n   📋 Step: force_unlock ${objectType}:${objectName}`);
+            const handle = lockHandle || this.lockManager.getLock(objectName, objectType)?.lockHandle || '';
+            const unlockUrl = buildAdtUnlockUrl(objectName, objectType, handle);
+            if (!unlockUrl) { results.push({ success: false, status: 0, error: `Unknown object type: ${objectType}` }); allSuccessful = false; break; }
+            const r = await this.sapClient.executeCallspec({ method: 'DELETE', url: unlockUrl, headers: {} });
+            if (r.success) this.lockManager.clearLock(objectName, objectType);
+            results.push(r);
+            if (!r.success) { allSuccessful = false; break; }
+            continue;
+          }
+          console.log(`\n   📋 Step: unknown command "${cs.command}" — skipping`);
+          results.push({ success: true, status: 200, data: { skipped: true, command: cs.command } });
+          continue;
+        }
+
         console.log(`\n   📋 Step: ${cs.name || cs.step}`);
         const isLockOp = cs.name === 'LOCK' || cs.url?.includes('_action=LOCK');
         if (isLockOp && objectName && objectType) {
@@ -751,16 +818,34 @@ class WebSocketClient {
             console.log(`   🔓 Injected lockHandle into UNLOCK URL from cache: ${cachedLock.lockHandle.substring(0,10)}...`);
           }
         }
+        const isUnlockOp = pcs.url?.includes('_action=UNLOCK');
         const result = await this.sapClient.executeCallspec(pcs);
         results.push(result);
-        if (result.success && result.data) {
-          if (result.data.lockHandle) {
+        if (result.success) {
+          if (result.data?.lockHandle) {
             extractedValues.lockHandle = result.data.lockHandle;
             if (isLockOp && objectName && objectType) this.lockManager.saveLock(objectName, objectType, result.data.lockHandle, result.data.transportRequest || '');
           }
-          if (result.data.transportRequest) extractedValues.transportRequest = result.data.transportRequest;
+          if (result.data?.transportRequest) extractedValues.transportRequest = result.data.transportRequest;
+          // After successful UNLOCK, clear the cached handle — it is now invalid on SAP
+          if (isUnlockOp && objectName && objectType) {
+            this.lockManager.clearLock(objectName, objectType);
+            console.log(`   🗑️  Lock handle cleared from cache after successful UNLOCK of ${objectType}:${objectName}`);
+          }
+        }
+        if (!result.success) {
+          // 423 with an invalid lock handle means the cached handle is stale — clear it so the
+          // next invocation does a fresh LOCK instead of reusing the dead handle
+          if (result.status === 423 && objectName && objectType) {
+            const stale = this.lockManager.getLock(objectName, objectType);
+            if (stale) {
+              this.lockManager.clearLock(objectName, objectType);
+              console.log(`   🗑️  Stale lock handle cleared from cache after 423 for ${objectType}:${objectName}`);
+            }
+          }
+          allSuccessful = false;
+          break;
         }
-        if (!result.success) { allSuccessful = false; break; }
       }
       return { results, allSuccessful };
     } else {