sap-ai-dev-toolkit 0.2.7 → 0.3.1

package/src/binary.mjs

@@ -3,6 +3,7 @@ import { chmod, mkdir, rename, stat, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { brandedEnvValue } from './branding.mjs';
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 export const UPSTREAM_COMMIT = '9886d2727f47506368b0a3c2f1c1766f1200f747';
@@ -17,7 +18,7 @@ const platformMap = {
 
 export function binaryTarget(platform = process.platform, arch = process.arch) {
   const target = platformMap[`${platform}:${arch}`];
-  if (!target) throw new Error(`Unsupported platform ${platform}/${arch}. Set BAS_VSP_BINARY or build cmd/vsp with scripts/build-vsp.mjs.`);
+  if (!target) throw new Error(`Unsupported platform ${platform}/${arch}. Set SAP_AI_DEV_TOOLKIT_BINARY or build cmd/vsp with scripts/build-vsp.mjs.`);
   return { os: target[0], arch: target[1], extension: target[2], asset: `vsp-${target[0]}-${target[1]}${target[2]}` };
 }
 
@@ -32,7 +33,7 @@ export function packageRepositoryUrl(pkg) {
 }
 
 export function releaseBaseUrl(pkg, version = pkg.version) {
-  const override = process.env.BAS_VSP_RELEASE_BASE_URL;
+  const override = brandedEnvValue(process.env, 'RELEASE_BASE_URL');
   if (override) return `${override.replace(/\/$/, '')}/v${version}`;
   const repo = packageRepositoryUrl(pkg).replace(/^ssh:\/\/git@github.com:/, 'https://github.com/').replace(/^git@github.com:/, 'https://github.com/');
   if (!repo.startsWith('http')) throw new Error('package repository URL must be an HTTPS URL for release assets');
@@ -43,48 +44,57 @@ export function cacheDirectory() {
   return process.env.BAS_VSP_CACHE_DIR || join(process.env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'sap-ai-dev-toolkit');
 }
 
-export function cachedBinaryPath(pkg, platform = process.platform, arch = process.arch) {
+export function cachedBinaryPath(pkg, platform = process.platform, arch = process.arch, env = process.env) {
   const target = binaryTarget(platform, arch);
-  return join(cacheDirectory(), `${pkg.name}-${pkg.version}-${target.asset}`);
+  return join(cacheDirectory(env), `${pkg.name}-${pkg.version}-${target.asset}`);
+}
+
+function legacyCachedBinaryPath(pkg, platform, arch, env) {
+  const target = binaryTarget(platform, arch);
+  const configuredCache = brandedEnvValue(env, 'CACHE_DIR');
+  const cacheRoot = configuredCache || join(env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'bas-mcp-addon');
+  return join(cacheRoot, `bas-mcp-addon-${pkg.version}-${target.asset}`);
 }
 
 export async function findBinary(pkg, options = {}) {
   const env = options.env || process.env;
-  if (env.BAS_VSP_BINARY) return env.BAS_VSP_BINARY;
-  if (!env.BAS_VSP_BINARY_URL) {
+  if (brandedEnvValue(env, 'BINARY')) return brandedEnvValue(env, 'BINARY');
+  if (!brandedEnvValue(env, 'BINARY_URL')) {
     const bundled = bundledBinaryPath(options.platform, options.arch);
     try { await stat(bundled); return bundled; } catch {}
   }
-  const path = cachedBinaryPath(pkg, options.platform, options.arch);
-  try { await stat(path); return path; } catch { return null; }
+  const path = cachedBinaryPath(pkg, options.platform, options.arch, env);
+  try { await stat(path); return path; } catch {}
+  const legacyPath = legacyCachedBinaryPath(pkg, options.platform, options.arch, env);
+  try { await stat(legacyPath); return legacyPath; } catch { return null; }
 }
 
 export async function installBinary(pkg, options = {}) {
   const env = options.env || process.env;
-  if (env.BAS_VSP_BINARY) return env.BAS_VSP_BINARY;
-  if (!env.BAS_VSP_BINARY_URL) {
+  if (brandedEnvValue(env, 'BINARY')) return brandedEnvValue(env, 'BINARY');
+  if (!brandedEnvValue(env, 'BINARY_URL')) {
     const bundled = bundledBinaryPath(options.platform, options.arch);
     try { await stat(bundled); return bundled; } catch {}
   }
   const target = binaryTarget(options.platform, options.arch);
   const base = releaseBaseUrl(pkg, pkg.version);
-  const assetUrl = env.BAS_VSP_BINARY_URL || `${base}/${target.asset}`;
+  const assetUrl = brandedEnvValue(env, 'BINARY_URL') || `${base}/${target.asset}`;
   const checksumUrl = `${base}/checksums.txt`;
   const response = await fetch(assetUrl);
-  if (!response.ok) throw new Error(`VSP binary download failed (${response.status}); set BAS_VSP_BINARY or BAS_VSP_BINARY_URL`);
+  if (!response.ok) throw new Error(`VSP binary download failed (${response.status}); set SAP_AI_DEV_TOOLKIT_BINARY or SAP_AI_DEV_TOOLKIT_BINARY_URL`);
   const bytes = Buffer.from(await response.arrayBuffer());
   const checksumResponse = await fetch(checksumUrl);
-  if (!checksumResponse.ok) throw new Error(`VSP checksum download failed (${checksumResponse.status}); set BAS_VSP_BINARY or BAS_VSP_BINARY_URL`);
+  if (!checksumResponse.ok) throw new Error(`VSP checksum download failed (${checksumResponse.status}); set SAP_AI_DEV_TOOLKIT_BINARY or SAP_AI_DEV_TOOLKIT_BINARY_URL`);
   const checksumText = await checksumResponse.text();
   const expected = checksumText.split(/\r?\n/).map(line => line.trim().split(/\s+/)).find(parts => parts.length >= 2 && (parts[1] === target.asset || parts[1].endsWith(`/${target.asset}`)))?.[0];
-  if (!expected) throw new Error(`checksums.txt has no entry for ${target.asset}; set BAS_VSP_BINARY or BAS_VSP_BINARY_URL`);
+  if (!expected) throw new Error(`checksums.txt has no entry for ${target.asset}; set SAP_AI_DEV_TOOLKIT_BINARY or SAP_AI_DEV_TOOLKIT_BINARY_URL`);
   const actual = createHash('sha256').update(bytes).digest('hex');
   if (actual.toLowerCase() !== expected.toLowerCase()) throw new Error(`VSP checksum mismatch for ${target.asset}`);
-  const dir = cacheDirectory();
+  const dir = cacheDirectory(env);
   await mkdir(dir, { recursive: true, mode: 0o700 });
   await chmod(dir, 0o700);
-  const destination = cachedBinaryPath(pkg, options.platform, options.arch);
-  const temporary = join(tmpdir(), `bas-vsp-${process.pid}-${Date.now()}`);
+  const destination = cachedBinaryPath(pkg, options.platform, options.arch, env);
+  const temporary = join(tmpdir(), `sap-ai-dev-toolkit-vsp-${process.pid}-${Date.now()}`);
   await writeFile(temporary, bytes, { mode: 0o700 });
   await chmod(temporary, 0o700);
   await rename(temporary, destination);

package/src/branding.mjs

@@ -0,0 +1,21 @@
+export const PRODUCT_NAME = 'sap-ai-dev-toolkit';
+export const ENV_PREFIX = 'SAP_AI_DEV_TOOLKIT_';
+
+const LEGACY_ENV_PREFIX = 'BAS_VSP_';
+
+export function brandedEnvValue(env, suffix) {
+  const name = suffix.startsWith(ENV_PREFIX) ? suffix.slice(ENV_PREFIX.length) : suffix;
+  const currentKey = `${ENV_PREFIX}${name}`;
+  const legacyKey = `${LEGACY_ENV_PREFIX}${name}`;
+  return env?.[currentKey] !== undefined ? env[currentKey] : env?.[legacyKey];
+}
+
+export function withBrandedEnvironment(env = process.env) {
+  const result = { ...env };
+  for (const [key, value] of Object.entries(env)) {
+    if (!key.startsWith(LEGACY_ENV_PREFIX)) continue;
+    const currentKey = `${ENV_PREFIX}${key.slice(LEGACY_ENV_PREFIX.length)}`;
+    if (result[currentKey] === undefined) result[currentKey] = value;
+  }
+  return result;
+}

package/src/cf-destination.mjs

@@ -695,7 +695,7 @@ export async function resolveConfiguredCloudFoundryDestination({ env = process.e
   const destinationInstanceGuid = configuredValue(env, 'BAS_CF_DESTINATION_INSTANCE_GUID');
   const destinationInstanceName = configuredValue(env, 'BAS_CF_DESTINATION_INSTANCE');
   const destinationKeyName = configuredValue(env, 'BAS_CF_DESTINATION_KEY');
-  const name = configuredValue(env, 'BAS_CF_DESTINATION_NAME') || configuredValue(env, 'BAS_VSP_DESTINATION');
+  const name = configuredValue(env, 'BAS_CF_DESTINATION_NAME') || text(brandedEnvValue(env, 'DESTINATION'));
   if (!spaceGuid || !destinationInstanceGuid || !destinationInstanceName || !destinationKeyName || !name) {
     throw new Error('Cloud Foundry destination configuration is incomplete; rerun sap-ai-dev --setup.');
   }

package/src/demo-vsp.mjs

@@ -0,0 +1,113 @@
+const objects = new Map([
+  ['CLAS:ZCL_DEMO_ORDER', `CLASS zcl_demo_order DEFINITION PUBLIC FINAL CREATE PUBLIC.\n  PUBLIC SECTION.\n    METHODS get_status IMPORTING order_id TYPE string RETURNING VALUE(status) TYPE string.\nENDCLASS.\n\nCLASS zcl_demo_order IMPLEMENTATION.\n  METHOD get_status.\n    status = |Order { order_id } is ready|.\n  ENDMETHOD.\nENDCLASS.`],
+  ['DDLS:ZI_DEMO_ORDER', `@EndUserText.label: 'Demo Orders'\ndefine view entity ZI_DEMO_ORDER\n  as select from zdemo_order\n{\n  key order_id as OrderId,\n      description as Description\n}`]
+]);
+
+const transports = new Map([
+  ['DEMO000001', { status: 'modifiable', description: 'Offline demo transport', objects: ['ZCL_DEMO_ORDER', 'ZI_DEMO_ORDER'] }]
+]);
+const tools = [
+  ['GetSource', { object_type: 'string', name: 'string' }, ['object_type', 'name']],
+  ['WriteSource', { object_type: 'string', name: 'string', source: 'string' }, ['object_type', 'name', 'source']],
+  ['SearchObject', { query: 'string' }, ['query']],
+  ['GetSystemInfo', {}, []],
+  ['GetFeatures', {}, []],
+  ['GetConnectionInfo', {}, []],
+  ['GetAPIReleaseState', { object_uri: 'string' }, ['object_uri']],
+  ['GetTransport', { transport: 'string' }, ['transport']],
+  ['ListTransports', {}, []],
+  ['GetTransportInfo', { object_url: 'string', dev_class: 'string' }, ['object_url', 'dev_class']],
+  ['ListDependencies', { object_uri: 'string' }, ['object_uri']],
+  ['GetInactiveObjects', {}, []],
+  ['RunUnitTests', { object_name: 'string' }, ['object_name']],
+  ['RunATCCheck', { object_name: 'string' }, ['object_name']],
+  ['SyntaxCheck', { object_type: 'string', name: 'string', source: 'string' }, ['object_type', 'name', 'source']],
+  ['CreateTransport', { description: 'string' }, ['description']]
+].map(([name, properties, required]) => ({
+  name,
+  description: `Offline demo fixture for ${name}. No live SAP system is contacted.`,
+  inputSchema: {
+    type: 'object',
+    properties: Object.fromEntries(Object.entries(properties).map(([key, type]) => [key, { type }])),
+    required,
+    additionalProperties: false
+  }
+}));
+
+function send(id, result) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
+}
+
+function toolResult(value) {
+  return { isError: false, content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value };
+}
+
+function errorResult(message) {
+  return { isError: true, content: [{ type: 'text', text: message }] };
+}
+
+function key(args) {
+  return `${String(args.object_type || '').toUpperCase()}:${String(args.name || '').toUpperCase()}`;
+}
+
+function getSource(args) {
+  const source = objects.get(key(args));
+  if (source === undefined) return errorResult(`Object ${args.object_type} ${args.name} is not in the demo fixture.`);
+  return { isError: false, content: [{ type: 'text', text: source }], structuredContent: { source } };
+}
+
+function callTool(name, args = {}) {
+  if (name === 'GetSource') return getSource(args);
+  if (name === 'WriteSource') {
+    objects.set(key(args), args.source);
+    return toolResult({ status: 'saved-in-memory', object_type: args.object_type, name: args.name });
+  }
+  if (name === 'SearchObject') {
+    const query = String(args.query || '').toUpperCase();
+    return toolResult({ objects: [...objects.keys()].filter(value => value.includes(query)).map(value => ({ name: value.split(':')[1], uri: `/sap/bc/adt/oo/classes/${value.split(':')[1].toLowerCase()}` })) });
+  }
+  if (name === 'GetSystemInfo') return toolResult({ system_id: 'DEMO', release: 'ABAP Platform 2023', database: 'Offline fixture' });
+  if (name === 'GetFeatures') return toolResult({ abap_cloud: true, rap_odata: true, cts_transports: true, offline_demo: true });
+  if (name === 'GetConnectionInfo') return toolResult({ destination: 'demo', connection: 'offline fixture', live_sap: false });
+  if (name === 'GetAPIReleaseState') {
+    return toolResult({ object_uri: args.object_uri, release_state: 'not_released', evidence: 'Synthetic API release-state example only.' });
+  }
+  if (name === 'GetTransport') return transports.has(args.transport) ? toolResult(transports.get(args.transport)) : errorResult(`Transport ${args.transport} is not in the demo fixture.`);
+  if (name === 'ListTransports') return toolResult({ transports: [...transports.entries()].map(([transport, details]) => ({ transport, ...details })) });
+  if (name === 'GetTransportInfo') return toolResult({ object_url: args.object_url, dev_class: args.dev_class, eligible_requests: ['DEMO000001'], lock_status: 'unlocked' });
+  if (name === 'ListDependencies') return toolResult({ dependencies: [], object_uri: args.object_uri, note: 'No additional dependencies in this fixture.' });
+  if (name === 'GetInactiveObjects') return toolResult({ objects: [] });
+  if (name === 'RunUnitTests') return toolResult({ object_name: args.object_name, status: 'passed', passed: 3, failed: 0, duration_ms: 18 });
+  if (name === 'RunATCCheck') return toolResult({ object_name: args.object_name, status: 'passed', findings: [] });
+  if (name === 'SyntaxCheck') return toolResult({ status: 'clean', errors: 0, warnings: 0 });
+  if (name === 'CreateTransport') {
+    const transport = `DEMO${String(transports.size + 1).padStart(6, '0')}`;
+    const result = { status: 'created-in-memory', transport, description: args.description };
+    transports.set(transport, result);
+    return toolResult(result);
+  }
+  return errorResult(`Tool ${name} is not implemented by the offline demo.`);
+}
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  buffer += chunk;
+  let newline;
+  while ((newline = buffer.indexOf('\n')) >= 0) {
+    const line = buffer.slice(0, newline).trim();
+    buffer = buffer.slice(newline + 1);
+    if (!line) continue;
+    let message;
+    try { message = JSON.parse(line); } catch { continue; }
+    if (message.method === 'initialize') {
+      send(message.id, { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'sap-ai-dev-toolkit-offline-demo', version: '1.0.0' } });
+    } else if (message.method === 'tools/list') {
+      send(message.id, { tools });
+    } else if (message.method === 'tools/call') {
+      send(message.id, callTool(message.params?.name, message.params?.arguments));
+    } else if (message.method && message.id !== undefined) {
+      send(message.id, {});
+    }
+  }
+});