abapgit-agent 1.0.0

package/src/abap-client.js

@@ -0,0 +1,314 @@
+/**
+ * ABAP Client - Connects to SAP ABAP system via REST/HTTP
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { getAbapConfig } = require('./config');
+const logger = require('./logger');
+
+class ABAPClient {
+  constructor() {
+    this.config = null;
+    this.cookieFile = path.join(__dirname, '..', '.abapgit_agent_cookies.txt');
+    this.csrfToken = null;
+  }
+
+  /**
+   * Get ABAP configuration
+   */
+  getConfig() {
+    if (!this.config) {
+      const cfg = getAbapConfig();
+      this.config = {
+        baseUrl: `https://${cfg.host}:${cfg.sapport || 44300}/sap/bc/z_abapgit_agent`,
+        username: cfg.user,
+        password: cfg.password,
+        client: cfg.client,
+        language: cfg.language || 'EN',
+        gitUsername: cfg.gitUsername,
+        gitPassword: cfg.gitPassword
+      };
+    }
+    return this.config;
+  }
+
+  /**
+   * Read cookies from Netscape format cookie file
+   */
+  readNetscapeCookies() {
+    if (!fs.existsSync(this.cookieFile)) return '';
+
+    const content = fs.readFileSync(this.cookieFile, 'utf8');
+    const lines = content.split('\n');
+    const cookies = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Skip empty lines and only the header comments (starting with #)
+      // but NOT HttpOnly cookies which start with #HttpOnly_
+      if (!trimmed || (trimmed.startsWith('#') && !trimmed.startsWith('#HttpOnly'))) continue;
+
+      const parts = trimmed.split('\t');
+      if (parts.length >= 7) {
+        // Format: domain, flag, path, secure, expiration, name, value
+        cookies.push(`${parts[5]}=${parts[6]}`);
+      }
+    }
+
+    return cookies.join('; ');
+  }
+
+  /**
+   * Make HTTP request
+   */
+  async request(method, path, data = null, options = {}) {
+    const cfg = this.getConfig();
+
+    return new Promise((resolve, reject) => {
+      const url = new URL(`${cfg.baseUrl}${path}`);
+
+      const headers = {
+        'Content-Type': 'application/json',
+        'sap-client': cfg.client,
+        'sap-language': cfg.language
+      };
+
+      // Add authorization
+      if (cfg.username) {
+        headers['Authorization'] = `Basic ${Buffer.from(`${cfg.username}:${cfg.password}`).toString('base64')}`;
+      }
+
+      // Add CSRF token for POST
+      if (method === 'POST' && options.csrfToken) {
+        headers['X-CSRF-Token'] = options.csrfToken;
+      }
+
+      // Add cookies if available (handle Netscape format)
+      const cookieHeader = this.readNetscapeCookies();
+      if (cookieHeader) {
+        headers['Cookie'] = cookieHeader;
+      }
+
+      const reqOptions = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method,
+        headers,
+        agent: new https.Agent({ rejectUnauthorized: false })
+      };
+
+      const req = (url.protocol === 'https:' ? https : http).request(reqOptions, (res) => {
+        // Update cookies
+        const setCookie = res.headers['set-cookie'];
+        if (setCookie) {
+          const cookies = Array.isArray(setCookie)
+            ? setCookie.map(c => c.split(';')[0]).join('; ')
+            : setCookie.split(';')[0];
+          fs.writeFileSync(this.cookieFile, cookies);
+        }
+
+        // Get CSRF token from response headers (for GET /pull with fetch)
+        if (res.headers['x-csrf-token'] && !this.csrfToken) {
+          this.csrfToken = res.headers['x-csrf-token'];
+        }
+
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            if (res.statusCode >= 400) {
+              logger.error(`REST request failed`, { status: res.statusCode, body });
+              reject(new Error(`REST request failed: ${res.statusCode}`));
+            } else if (body) {
+              resolve(JSON.parse(body));
+            } else {
+              resolve({});
+            }
+          } catch (e) {
+            resolve(body);
+          }
+        });
+      });
+
+      req.on('error', reject);
+
+      if (data) {
+        req.write(JSON.stringify(data));
+      }
+      req.end();
+    });
+  }
+
+  /**
+   * Fetch CSRF token using GET /pull with X-CSRF-Token: fetch
+   */
+  async fetchCsrfToken() {
+    const cfg = this.getConfig();
+
+    return new Promise((resolve, reject) => {
+      const url = new URL(`${cfg.baseUrl}/pull`);
+
+      // Clear stale cookies before fetching new token
+      if (fs.existsSync(this.cookieFile)) {
+        fs.unlinkSync(this.cookieFile);
+      }
+
+      // Read cookies for sending (handle Netscape format)
+      const cookieHeader = this.readNetscapeCookies();
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: 'GET',
+        headers: {
+          'Authorization': `Basic ${Buffer.from(`${cfg.username}:${cfg.password}`).toString('base64')}`,
+          'sap-client': cfg.client,
+          'sap-language': cfg.language,
+          'X-CSRF-Token': 'fetch',
+          'Content-Type': 'application/json',
+          ...(cookieHeader && { 'Cookie': cookieHeader })
+        },
+        agent: new https.Agent({ rejectUnauthorized: false })
+      };
+
+      const req = https.request(options, (res) => {
+        const csrfToken = res.headers['x-csrf-token'];
+
+        // Save new cookies from response - the CSRF token is tied to this new session!
+        const setCookie = res.headers['set-cookie'];
+        if (setCookie) {
+          const cookies = Array.isArray(setCookie)
+            ? setCookie.map(c => c.split(';')[0]).join('; ')
+            : setCookie.split(';')[0];
+          fs.writeFileSync(this.cookieFile, cookies);
+        }
+
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          // Store token in instance for use by POST
+          this.csrfToken = csrfToken;
+          resolve({ token: csrfToken });
+        });
+      });
+
+      req.on('error', reject);
+      req.end();
+    });
+  }
+
+  /**
+   * Pull repository and activate
+   * Uses command API if useCommandApi config is enabled, otherwise uses legacy /pull endpoint
+   * @param {string} repoUrl - Repository URL
+   * @param {string} branch - Branch name (default: 'main')
+   * @param {string} gitUsername - Git username (optional)
+   * @param {string} gitPassword - Git password/token (optional)
+   * @param {Array} files - Array of file paths to pull (optional)
+   * @param {string} transportRequest - Transport request number (optional)
+   * @returns {object} Pull result
+   */
+  async pull(repoUrl, branch = 'main', gitUsername = null, gitPassword = null, files = null, transportRequest = null) {
+    const cfg = this.getConfig();
+
+    // Fetch CSRF token first (using GET /pull with X-CSRF-Token: fetch)
+    await this.fetchCsrfToken();
+
+    const data = {
+      url: repoUrl,
+      branch: branch
+    };
+
+    // Add files if specified
+    if (files && files.length > 0) {
+      data.files = files;
+    }
+
+    // Add transport request if specified
+    if (transportRequest) {
+      data.transport_request = transportRequest;
+    }
+
+    // Use config git credentials if no override provided
+    data.username = gitUsername || cfg.gitUsername;
+    data.password = gitPassword || cfg.gitPassword;
+
+    logger.info('Starting pull operation', { repoUrl, branch, transportRequest, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/pull', data, { csrfToken: this.csrfToken });
+  }
+
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    try {
+      const result = await this.request('GET', '/health');
+      return { status: 'healthy', abap: 'connected', ...result };
+    } catch (error) {
+      return { status: 'unhealthy', abap: 'disconnected', error: error.message };
+    }
+  }
+
+  /**
+   * Check syntax of an ABAP object
+   */
+  async syntaxCheck(objectType, objectName) {
+    // Fetch CSRF token first
+    await this.fetchCsrfToken();
+
+    const data = {
+      object_type: objectType,
+      object_name: objectName
+    };
+
+    logger.info('Starting syntax check', { objectType, objectName, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/syntax-check', data, { csrfToken: this.csrfToken });
+  }
+
+  /**
+   * Run unit tests for package or objects
+   * @param {string} packageName - Package name to run tests for (optional)
+   * @param {Array} objects - Array of {object_type, object_name} objects (optional)
+   * @returns {object} Unit test results
+   */
+  async unitTest(packageName = null, objects = []) {
+    // Fetch CSRF token first
+    await this.fetchCsrfToken();
+
+    const data = {};
+
+    if (packageName) {
+      data.package = packageName;
+    }
+
+    if (objects && objects.length > 0) {
+      data.objects = objects;
+    }
+
+    logger.info('Starting unit tests', { package: packageName, objects, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/unit', data, { csrfToken: this.csrfToken });
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+function getClient() {
+  if (!instance) {
+    instance = new ABAPClient();
+  }
+  return instance;
+}
+
+module.exports = {
+  ABAPClient,
+  getClient
+};

package/src/agent.js

@@ -0,0 +1,119 @@
+/**
+ * ABAP Git Agent - Main agent class
+ */
+
+const { getClient } = require('./abap-client');
+const logger = require('./logger');
+
+class ABAPGitAgent {
+  constructor() {
+    this.abap = getClient();
+  }
+
+  /**
+   * Pull repository and activate objects
+   * @param {string} repoUrl - Git repository URL
+   * @param {string} branch - Branch name (default: main)
+   * @param {string} username - Git username (optional)
+   * @param {string} password - Git password/token (optional)
+   * @param {Array} files - Specific files to pull (optional)
+   * @returns {object} Pull result with success, job_id, message, error_detail
+   */
+  async pull(repoUrl, branch = 'main', username = null, password = null, files = null) {
+    logger.info('Starting pull operation', { repoUrl, branch, username: !!username, files });
+
+    try {
+      const result = await this.abap.pull(repoUrl, branch, username, password, files);
+
+      // Return the result directly from ABAP (handle uppercase keys from /UI2/CL_JSON)
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        job_id: result.JOB_ID || result.job_id,
+        message: result.MESSAGE || result.message,
+        error_detail: result.ERROR_DETAIL || result.error_detail || null,
+        activated_count: result.ACTIVATED_COUNT || result.activated_count || 0,
+        failed_count: result.FAILED_COUNT || result.failed_count || 0,
+        activated_objects: result.ACTIVATED_OBJECTS || result.activated_objects || [],
+        failed_objects: result.FAILED_OBJECTS || result.failed_objects || []
+      };
+
+    } catch (error) {
+      logger.error('Pull failed', { error: error.message });
+      throw new Error(`Pull failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Health check
+   * @returns {object} Health status
+   */
+  async healthCheck() {
+    try {
+      const result = await this.abap.healthCheck();
+      return {
+        status: 'healthy',
+        abap: 'connected',
+        version: result.version || '1.0.0'
+      };
+    } catch (error) {
+      return {
+        status: 'unhealthy',
+        abap: 'disconnected',
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Check syntax of an ABAP object
+   * @param {string} objectType - ABAP object type (e.g., 'CLAS', 'PROG', 'INTF')
+   * @param {string} objectName - ABAP object name
+   * @returns {object} Syntax check result with errors (if any)
+   */
+  async syntaxCheck(objectType, objectName) {
+    logger.info('Starting syntax check', { objectType, objectName });
+
+    try {
+      const result = await this.abap.syntaxCheck(objectType, objectName);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        object_type: result.OBJECT_TYPE || result.object_type,
+        object_name: result.OBJECT_NAME || result.object_name,
+        error_count: result.ERROR_COUNT || result.error_count || 0,
+        errors: result.ERRORS || result.errors || []
+      };
+    } catch (error) {
+      logger.error('Syntax check failed', { error: error.message });
+      throw new Error(`Syntax check failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Run unit tests for package or objects
+   * @param {string} packageName - Package name to run tests for (optional)
+   * @param {Array} objects - Array of {object_type, object_name} objects (optional)
+   * @returns {object} Unit test results with test_count, passed_count, failed_count, results
+   */
+  async unitCheck(packageName = null, objects = []) {
+    logger.info('Starting unit tests', { package: packageName, objects });
+
+    try {
+      const result = await this.abap.unitTest(packageName, objects);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        test_count: result.TEST_COUNT || result.test_count || 0,
+        passed_count: result.PASSED_COUNT || result.passed_count || 0,
+        failed_count: result.FAILED_COUNT || result.failed_count || 0,
+        message: result.MESSAGE || result.message || '',
+        errors: result.ERRORS || result.errors || []
+      };
+    } catch (error) {
+      logger.error('Unit tests failed', { error: error.message });
+      throw new Error(`Unit tests failed: ${error.message}`);
+    }
+  }
+}
+
+module.exports = {
+  ABAPGitAgent
+};

package/src/config.js

@@ -0,0 +1,66 @@
+/**
+ * Configuration loader
+ * Loads config from .abapGitAgent or environment variables
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let config = null;
+
+function loadConfig() {
+  if (config) return config;
+
+  // First check current working directory (repo root) - for system-level integration
+  const repoConfigPath = path.join(process.cwd(), '.abapGitAgent');
+  if (fs.existsSync(repoConfigPath)) {
+    config = JSON.parse(fs.readFileSync(repoConfigPath, 'utf8'));
+    return config;
+  }
+
+  // Fallback to package directory (for legacy/compatibility)
+  const configPath = process.env.CONFIG_PATH || path.join(__dirname, '..', '.abapGitAgent');
+
+  if (fs.existsSync(configPath)) {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } else {
+    // Load from environment variables
+    config = {
+      host: process.env.ABAP_HOST,
+      sapport: parseInt(process.env.ABAP_PORT, 10) || 443,
+      client: process.env.ABAP_CLIENT || '100',
+      user: process.env.ABAP_USER,
+      password: process.env.ABAP_PASSWORD,
+      language: process.env.ABAP_LANGUAGE || 'EN',
+      gitUsername: process.env.GIT_USERNAME,
+      gitPassword: process.env.GIT_PASSWORD
+    };
+  }
+
+  return config;
+}
+
+function getAbapConfig() {
+  const cfg = loadConfig();
+  return {
+    host: cfg.host,
+    sapport: cfg.sapport || 443,
+    client: cfg.client,
+    user: cfg.user,
+    password: cfg.password,
+    language: cfg.language || 'EN',
+    gitUsername: cfg.gitUsername || process.env.GIT_USERNAME,
+    gitPassword: cfg.gitPassword || process.env.GIT_PASSWORD
+  };
+}
+
+function getAgentConfig() {
+  const cfg = loadConfig();
+  return cfg.agent;
+}
+
+module.exports = {
+  loadConfig,
+  getAbapConfig,
+  getAgentConfig
+};

package/src/index.js

@@ -0,0 +1,48 @@
+/**
+ * ABAP Git Agent - Package Entry Point
+ *
+ * Exports functions for programmatic use:
+ *   const { pull, healthCheck } = require('abapgit-agent');
+ */
+
+const { ABAPGitAgent } = require('./agent');
+
+/**
+ * Pull repository and activate objects
+ * @param {string} repoUrl - Git repository URL
+ * @param {string} branch - Branch name (default: main)
+ * @param {string} username - Git username (optional)
+ * @param {string} password - Git password/token (optional)
+ * @returns {object} Pull result with success, job_id, message, error_detail
+ */
+async function pull(repoUrl, branch = 'main', username = null, password = null) {
+  const agent = new ABAPGitAgent();
+  return await agent.pull(repoUrl, branch, username, password);
+}
+
+/**
+ * Check agent health
+ * @returns {object} Health status
+ */
+async function healthCheck() {
+  const agent = new ABAPGitAgent();
+  return await agent.healthCheck();
+}
+
+/**
+ * Check if integration is configured for current directory
+ * @returns {boolean} True if .abapGitAgent exists
+ */
+function isConfigured() {
+  const fs = require('fs');
+  const path = require('path');
+  const repoConfigPath = path.join(process.cwd(), '.abapGitAgent');
+  return fs.existsSync(repoConfigPath);
+}
+
+module.exports = {
+  pull,
+  healthCheck,
+  isConfigured,
+  ABAPGitAgent
+};

package/src/logger.js

@@ -0,0 +1,39 @@
+/**
+ * Logger module using Winston
+ */
+
+const winston = require('winston');
+const path = require('path');
+const fs = require('fs');
+
+const logDir = path.join(__dirname, '..', 'logs');
+if (!fs.existsSync(logDir)) {
+  fs.mkdirSync(logDir, { recursive: true });
+}
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'abapgit-agent' },
+  transports: [
+    new winston.transports.File({
+      filename: path.join(logDir, 'error.log'),
+      level: 'error'
+    }),
+    new winston.transports.File({
+      filename: path.join(logDir, 'combined.log')
+    }),
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple()
+      )
+    })
+  ]
+});
+
+module.exports = logger;

package/src/server.js

@@ -0,0 +1,116 @@
+/**
+ * HTTP Server for Claude Integration
+ */
+
+const express = require('express');
+const cors = require('cors');
+const { ABAPGitAgent } = require('./agent');
+const { getAgentConfig } = require('./config');
+const logger = require('./logger');
+
+class Server {
+  constructor() {
+    this.app = express();
+    this.agent = new ABAPGitAgent();
+    this.agentConfig = getAgentConfig();
+
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  setupMiddleware() {
+    this.app.use(cors());
+    this.app.use(express.json());
+
+    // Request logging
+    this.app.use((req, res, next) => {
+      logger.debug(`${req.method} ${req.path}`, { body: req.body });
+      next();
+    });
+
+    // Error handling
+    this.app.use((err, req, res, next) => {
+      logger.error('Request error', { error: err.message, stack: err.stack });
+      res.status(500).json({
+        success: false,
+        error: err.message
+      });
+    });
+  }
+
+  setupRoutes() {
+    // Health check
+    this.app.get('/api/health', async (req, res) => {
+      try {
+        const health = await this.agent.healthCheck();
+        res.json(health);
+      } catch (error) {
+        res.status(503).json({
+          status: 'unhealthy',
+          error: error.message
+        });
+      }
+    });
+
+    // Pull repository (synchronous - returns immediately with result)
+    this.app.post('/api/pull', async (req, res) => {
+      try {
+        const { url, branch, username, password } = req.body;
+
+        if (!url) {
+          return res.status(400).json({
+            success: false,
+            error: 'Missing required parameter: url'
+          });
+        }
+
+        const result = await this.agent.pull(url, branch, username, password);
+        res.json(result);
+
+      } catch (error) {
+        logger.error('Pull failed', { error: error.message });
+        res.status(500).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+  }
+
+  start() {
+    const port = this.agentConfig.port || 3000;
+
+    this.server = this.app.listen(port, () => {
+      logger.info(`ABAP AI Bridge server started on port ${port}`);
+      console.log(`\n🚀 ABAP AI Bridge is running!`);
+      console.log(`   Health:   http://localhost:${port}/api/health`);
+      console.log(`   Pull:     POST http://localhost:${port}/api/pull`);
+      console.log(`\n📚 API Documentation:`);
+      console.log(`   POST /api/pull { "url": "git-url", "branch": "main" }`);
+    });
+
+    // Graceful shutdown
+    process.on('SIGTERM', () => this.shutdown());
+    process.on('SIGINT', () => this.shutdown());
+  }
+
+  shutdown() {
+    logger.info('Shutting down server...');
+    if (this.server) {
+      this.server.close(() => {
+        logger.info('Server closed');
+        process.exit(0);
+      });
+    }
+  }
+}
+
+// Start server if run directly
+if (require.main === module) {
+  const server = new Server();
+  server.start();
+}
+
+module.exports = {
+  Server
+};