sap-ai-dev-toolkit 0.2.5

package/src/launcher.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { discoverDestinations, remediation, statusRows } from './bas-discovery.mjs';
+import { findBinary } from './binary.mjs';
+import { MCPProxy } from './mcp-proxy.mjs';
+import { installMcpConfig } from './mcp-config.mjs';
+import { runSetup } from './setup.mjs';
+import { resolveConfiguredCloudFoundryDestination } from './cf-destination.mjs';
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+
+function hasFlag(name) { return process.argv.slice(2).includes(name); }
+function json(value) { process.stdout.write(`${JSON.stringify(value)}\n`); }
+
+function usage() {
+  return [
+    'Usage: sap-ai-dev [options]',
+    '',
+    'With H2O_URL set and no command, starts the BAS MCP stdio server.',
+    'Options:',
+    '  --setup                  Configure generated BAS MCP servers',
+    '  --tools                  Also offer full-stack SAP companion MCP servers (use with --setup)',
+    '  --npx                    Launch configured MCP servers through the pinned npm package (use with --setup)',
+    '  --list-destinations      List discovered BAS destinations',
+    '  --list-destinations --json  Print redacted JSON status',
+    '  --check                  Probe destination availability',
+    '  --help, -h               Show this help and exit',
+    '',
+    'Use an MCP client to call server tools; the BAS runtime uses stdio for MCP.',
+    ''
+  ].join('\n');
+}
+
+function probeDiagnostic(destination) {
+  const probe = destination.probe || {};
+  const details = [];
+  if (probe.httpStatus) details.push(`HTTP ${probe.httpStatus}`);
+  if (probe.error) {
+    const error = String(probe.error)
+      .replace(/(authorization|cookie|password|secret|token)\s*[:=]\s*[^\s,;]+/gi, '$1=[redacted]')
+      .replace(/\s+/g, ' ')
+      .slice(0, 400);
+    details.push(error);
+  }
+  return `[sap-ai-dev] ${destination.name}: probe=${probe.status || 'unknown'}${details.length ? ` (${details.join('; ')})` : ''}`;
+}
+
+async function binaryOrError() {
+  const path = await findBinary(pkg);
+  if (path) return path;
+  throw new Error('VSP binary is not installed. Reinstall with scripts enabled, set BAS_VSP_BINARY to a trusted patched binary, or run npm run build:vsp.');
+}
+
+async function discoverForCommand() {
+  const env = { ...process.env };
+  if (env.BAS_VSP_DESTINATION_SOURCE === 'cloud-foundry') env.BAS_VSP_DESTINATION = '';
+  return discoverDestinations({ env });
+}
+
+async function main() {
+  const setup = hasFlag('--setup');
+  const check = hasFlag('--check');
+  const list = hasFlag('--list-destinations');
+  if (hasFlag('--help') || hasFlag('-h')) {
+    process.stdout.write(usage());
+    return;
+  }
+  if (setup) {
+    const setupOptions = {
+      includeSapDevelopmentToolsPrompt: hasFlag('--tools') || hasFlag('--companion-tools')
+    };
+    if (hasFlag('--npx')) {
+      setupOptions.install = (selected, options) => installMcpConfig(selected, {
+        ...options,
+        command: 'npx',
+        args: ['--yes', '--ignore-scripts', `--package=sap-ai-dev-toolkit@${pkg.version}`, 'sap-ai-dev']
+      });
+    }
+    await runSetup(setupOptions);
+    return;
+  }
+  if (check || list) {
+    const destinations = await discoverForCommand();
+    const statuses = statusRows(destinations);
+    if (list && hasFlag('--json')) json(statuses);
+    else for (const row of statuses) console.error(`${row.name}: client=${row.client} authentication=${row.authentication} probe=${row.probe}`);
+    if (check && !destinations.some(destination => destination.probe?.available)) {
+      throw new Error('No BAS destination answered the ADT discovery probe successfully. Review the probe results above.');
+    }
+    return;
+  }
+
+  if (process.env.BAS_VSP_DESTINATION_SOURCE === 'cloud-foundry') {
+    const destination = await resolveConfiguredCloudFoundryDestination({ env: process.env });
+    let proxy;
+    try {
+      const binary = await binaryOrError();
+      proxy = new MCPProxy({ binary, destinations: [destination], env: process.env, log: message => console.error(message) });
+      const shutdown = signal => { void proxy.close().finally(() => process.exit(signal === 'SIGINT' ? 130 : 143)); };
+      process.once('SIGINT', () => shutdown('SIGINT'));
+      process.once('SIGTERM', () => shutdown('SIGTERM'));
+      await proxy.serve(process.stdin);
+    } catch (error) {
+      await proxy?.close();
+      await destination.close?.();
+      throw error;
+    }
+    return;
+  }
+
+  if (!process.env.H2O_URL) {
+    const binary = await binaryOrError();
+    const child = spawn(binary, process.argv.slice(2), { env: process.env, stdio: 'inherit' });
+    process.once('SIGINT', () => child.kill('SIGINT'));
+    process.once('SIGTERM', () => child.kill('SIGTERM'));
+    const [code, signal] = await new Promise(resolve => child.once('exit', (exitCode, exitSignal) => resolve([exitCode, exitSignal])));
+    if (signal) process.kill(process.pid, signal);
+    process.exitCode = code ?? 1;
+    return;
+  }
+
+  const discovered = await discoverDestinations({ env: process.env });
+  for (const destination of discovered) console.error(probeDiagnostic(destination));
+  const destinations = discovered;
+  if (!destinations.length) {
+    console.error('[sap-ai-dev] destination discovery returned no named BAS destinations');
+    throw new Error(remediation);
+  }
+  const binary = await binaryOrError();
+  console.error(`[sap-ai-dev] starting MCP proxy for ${destinations.map(destination => `${destination.name} (client=${destination.client})`).join(', ')}`);
+  const proxy = new MCPProxy({ binary, destinations, env: process.env, log: message => console.error(message) });
+  const shutdown = signal => { void proxy.close().finally(() => process.exit(signal === 'SIGINT' ? 130 : 143)); };
+  process.once('SIGINT', () => shutdown('SIGINT'));
+  process.once('SIGTERM', () => shutdown('SIGTERM'));
+  await proxy.serve(process.stdin);
+}
+
+main().catch(error => {
+  console.error(`sap-ai-dev: ${error.message}`);
+  process.exitCode = 1;
+});

package/src/mcp-config.mjs

@@ -0,0 +1,253 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+const LEGACY_MCP_SERVER_PREFIXES = ['sapAiDev_', 'basVspMcp_'];
+const COMPANION_SERVER_KIND = 'sap-development-companion';
+
+export const SAP_DEVELOPMENT_MCP_SERVERS = Object.freeze([
+  Object.freeze({
+    id: 'sap-fiori-tools',
+    name: 'SAP Fiori tools',
+    description: 'SAP Fiori elements/freestyle project generation, annotations, and UX guidance.',
+    packageName: '@sap-ux/fiori-mcp-server',
+    bin: 'fiori-mcp',
+    priority: 'recommended'
+  }),
+  Object.freeze({
+    id: 'ui5-tools',
+    name: 'UI5 tools',
+    description: 'SAPUI5/OpenUI5 project inspection, UI5-aware help, and lint/project support.',
+    packageName: '@ui5/mcp-server',
+    bin: 'ui5mcp',
+    priority: 'recommended'
+  }),
+  Object.freeze({
+    id: 'cap-tools',
+    name: 'CAP tools',
+    description: 'CAP CDS/service model inspection and AI-assisted CAP application development.',
+    packageName: '@cap-js/mcp-server',
+    bin: 'cds-mcp',
+    priority: 'recommended'
+  }),
+  Object.freeze({
+    id: 'browser-validation',
+    name: 'Browser validation',
+    description: 'Playwright browser automation for Fiori/UI smoke tests, screenshots, and runtime checks.',
+    packageName: '@playwright/mcp',
+    bin: 'playwright-mcp',
+    priority: 'recommended'
+  })
+]);
+
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error?.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+export async function resolveMcpConfigPath(env = process.env) {
+  if (env.SAP_AI_DEV_MCP_CONFIG) return env.SAP_AI_DEV_MCP_CONFIG;
+  if (env.BAS_VSP_MCP_CONFIG) return env.BAS_VSP_MCP_CONFIG;
+  const home = env.HOME || homedir();
+  const candidates = [
+    join(home, '.vscode', 'data', 'User', 'mcp.json'),
+    join(home, '.vscode-server', 'data', 'User', 'mcp.json'),
+    join(home, '.code-server', 'data', 'User', 'mcp.json')
+  ];
+  for (const candidate of candidates) if (await exists(candidate)) return candidate;
+  return candidates[0];
+}
+
+export function generatedServerName(destinationName) {
+  return String(destinationName);
+}
+
+export function buildSapDevelopmentMcpEntries(serverIds = SAP_DEVELOPMENT_MCP_SERVERS.map(server => server.id), { packageVersions = {}, packageManager = 'npx' } = {}) {
+  const selected = new Set(serverIds);
+  const entries = Object.create(null);
+  for (const server of SAP_DEVELOPMENT_MCP_SERVERS) {
+    if (!selected.has(server.id)) continue;
+    const packageSpec = packageVersions[server.id] || packageVersions[server.packageName] || server.packageName;
+    entries[server.id] = {
+      type: 'stdio',
+      command: packageManager,
+      args: ['--yes', `--package=${packageSpec}`, server.bin],
+      BAS_EXT: 'true',
+      BAS_EXT_KIND: COMPANION_SERVER_KIND,
+      displayName: server.name,
+      description: server.description
+    };
+  }
+  const unknown = [...selected].filter(id => !SAP_DEVELOPMENT_MCP_SERVERS.some(server => server.id === id));
+  if (unknown.length) throw new Error(`Unknown SAP development MCP server id${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}`);
+  return entries;
+}
+
+export function buildMcpEntries(destinations, env = process.env) {
+  const h2oUrl = env.H2O_URL;
+  if (!h2oUrl) throw new Error('H2O_URL is required to write BAS MCP configuration');
+  const entries = Object.create(null);
+  const selected = [...destinations].sort((a, b) => String(a.serverName || a.name).localeCompare(String(b.serverName || b.name)));
+  for (const destination of selected) {
+    const isCf = destination.source === 'cloud-foundry';
+    const name = generatedServerName(isCf ? destination.serverName : destination.name);
+    if (Object.hasOwn(entries, name)) throw new Error(`Duplicate MCP destination server name: ${name}`);
+    const entryEnv = {
+      H2O_URL: String(h2oUrl),
+      SAP_ALLOW_TRANSPORTABLE_EDITS: 'true'
+    };
+    if (isCf) {
+      const cf = destination.cf;
+      if (!cf) throw new Error(`Cloud Foundry destination "${destination.name}" is missing service references`);
+      Object.assign(entryEnv, {
+        BAS_VSP_DESTINATION_SOURCE: 'cloud-foundry',
+        BAS_VSP_DESTINATION: String(destination.name),
+        BAS_CF_SPACE_GUID: String(cf.spaceGuid),
+        BAS_CF_DESTINATION_INSTANCE_GUID: String(cf.destinationInstanceGuid),
+        BAS_CF_DESTINATION_INSTANCE: String(cf.destinationInstanceName),
+        BAS_CF_DESTINATION_KEY: String(cf.destinationKeyName),
+        BAS_CF_DESTINATION_NAME: String(destination.name)
+      });
+      if (destination.proxyType?.toLowerCase() === 'onpremise') {
+        Object.assign(entryEnv, {
+          BAS_CF_CONNECTIVITY_INSTANCE_GUID: String(cf.connectivityInstanceGuid),
+          BAS_CF_CONNECTIVITY_INSTANCE: String(cf.connectivityInstanceName),
+          BAS_CF_CONNECTIVITY_KEY: String(cf.connectivityKeyName)
+        });
+      }
+    } else {
+      entryEnv.BAS_VSP_DESTINATION = String(destination.name);
+    }
+    entries[name] = {
+      type: 'stdio',
+      command: 'sap-ai-dev',
+      env: entryEnv,
+      BAS_EXT: 'true'
+    };
+  }
+  return entries;
+}
+
+function isCompanionServer(entry) {
+  return entry?.BAS_EXT === 'true' && entry?.BAS_EXT_KIND === COMPANION_SERVER_KIND;
+}
+
+function isPackageLauncher(entry) {
+  const commands = new Set(['sap-ai-dev', 'bas-vsp-mcp']);
+  const packages = [/^--package=sap-ai-dev-toolkit(?:@[^/]+)?$/, /^--package=bas-mcp-addon(?:@[^/]+)?$/];
+  const npxLauncher = entry?.command === 'npx'
+    && Array.isArray(entry.args)
+    && entry.args.some(argument => commands.has(argument))
+    && entry.args.some(argument => typeof argument === 'string' && packages.some(pattern => pattern.test(argument)));
+  return entry?.BAS_EXT === 'true' && (commands.has(entry?.command) || npxLauncher);
+}
+
+function collectCloudFoundryKeyReferences(config, managedOnly) {
+  const refs = new Map();
+  for (const entry of Object.values(config?.servers || {})) {
+    const e = entry?.env;
+    if (!e || (managedOnly && (e.BAS_VSP_DESTINATION_SOURCE !== 'cloud-foundry' || !isPackageLauncher(entry)))) continue;
+    const candidates = [
+      { kind: 'destination', spaceGuid: e.BAS_CF_SPACE_GUID, instanceGuid: e.BAS_CF_DESTINATION_INSTANCE_GUID, instanceName: e.BAS_CF_DESTINATION_INSTANCE, keyName: e.BAS_CF_DESTINATION_KEY },
+      { kind: 'connectivity', spaceGuid: e.BAS_CF_SPACE_GUID, instanceGuid: e.BAS_CF_CONNECTIVITY_INSTANCE_GUID, instanceName: e.BAS_CF_CONNECTIVITY_INSTANCE, keyName: e.BAS_CF_CONNECTIVITY_KEY }
+    ];
+    for (const ref of candidates) {
+      if (!ref.spaceGuid || !ref.instanceGuid || !ref.instanceName || !ref.keyName) continue;
+      refs.set(`${ref.kind}\\0${ref.spaceGuid}\\0${ref.instanceGuid}\\0${ref.keyName}`, ref);
+    }
+  }
+  return [...refs.values()];
+}
+
+export function collectManagedCloudFoundryKeyReferences(config) {
+  return collectCloudFoundryKeyReferences(config, true);
+}
+
+export function collectCloudFoundryKeyReferencesFromAllEntries(config) {
+  return collectCloudFoundryKeyReferences(config, false);
+}
+
+async function readConfig(path) {
+  let raw;
+  try {
+    raw = await readFile(path, 'utf8');
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { servers: {}, inputs: [] };
+    throw new Error(`MCP config ${path} could not be read: ${error.message}`);
+  }
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`MCP config ${path} contains invalid JSON: ${error.message}`);
+  }
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`MCP config ${path} must contain a top-level JSON object`);
+  }
+  if (config.servers !== undefined && (!config.servers || typeof config.servers !== 'object' || Array.isArray(config.servers))) {
+    throw new Error(`MCP config ${path} has a non-object servers value`);
+  }
+  return { ...config, servers: config.servers || {} };
+}
+
+async function writeConfig(path, config) {
+  const directory = dirname(path);
+  await mkdir(directory, { recursive: true });
+  const temporary = join(directory, `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    await writeFile(temporary, `${JSON.stringify(config, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temporary, path);
+  } catch (error) {
+    await rm(temporary, { force: true }).catch(() => {});
+    throw new Error(`MCP config ${path} could not be written: ${error.message}`);
+  }
+}
+
+export async function installMcpConfig(destinationsOrOptions, options = {}) {
+  let destinations = destinationsOrOptions;
+  if (!Array.isArray(destinationsOrOptions)) {
+    destinations = destinationsOrOptions?.destinations || [];
+    options = destinationsOrOptions || {};
+  }
+  const env = options.env || process.env;
+  const path = options.path || await resolveMcpConfigPath(env);
+  const config = await readConfig(path);
+  const generated = {
+    ...buildMcpEntries(destinations, env),
+    ...buildSapDevelopmentMcpEntries(options.sapDevelopmentServers || [])
+  };
+  if (options.command) {
+    for (const entry of Object.values(generated)) {
+      if (isCompanionServer(entry)) continue;
+      entry.command = options.command;
+      if (options.args?.length) entry.args = [...options.args];
+    }
+  }
+  const servers = Object.create(null);
+  for (const [name, entry] of Object.entries(config.servers)) {
+    const managed = isPackageLauncher(entry)
+      && typeof entry?.env?.BAS_VSP_DESTINATION === 'string'
+      && (entry.env.BAS_VSP_DESTINATION_SOURCE === 'cloud-foundry'
+        ? typeof entry.env.BAS_CF_DESTINATION_KEY === 'string'
+        : entry.env.BAS_VSP_DESTINATION_SOURCE === undefined);
+    if (!LEGACY_MCP_SERVER_PREFIXES.some(prefix => name.startsWith(prefix)) && !managed && !isCompanionServer(entry)) servers[name] = entry;
+  }
+  for (const name of Object.keys(generated)) {
+    if (Object.hasOwn(servers, name)) {
+      throw new Error(`MCP server "${name}" already exists and is not managed by sap-ai-dev-toolkit`);
+    }
+  }
+  config.servers = { ...servers, ...generated };
+  await writeConfig(path, config);
+  return { path, servers: generated };
+}
+
+export async function readMcpConfig(path) {
+  return readConfig(path);
+}