sap-ai-dev-toolkit 0.2.5

package/test/launcher.test.mjs

@@ -0,0 +1,164 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const launcher = fileURLToPath(new URL('../src/launcher.mjs', import.meta.url));
+const fakeVsp = fileURLToPath(new URL('./fixtures/fake-vsp.mjs', import.meta.url));
+
+function runLauncher(args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [launcher, ...args], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => resolve({ code, signal, stdout, stderr }));
+  });
+}
+function runLauncherTty(env, input, args = ['--setup']) {
+  return new Promise((resolve, reject) => {
+    const command = `${process.execPath} ${launcher} ${args.join(' ')}`;
+    const child = spawn('script', ['-qec', command, '/dev/null'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    let inputSent = false;
+    child.stdout.on('data', chunk => {
+      stdout += chunk.toString();
+      if (!inputSent && stdout.includes('Select destinations')) {
+        inputSent = true;
+        child.stdin.end(input);
+      }
+    });
+    child.stderr.on('data', chunk => { stderr += chunk.toString(); });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => resolve({ code, signal, stdout, stderr }));
+  });
+}
+
+test('help exits before BAS destination discovery', async t => {
+  let requests = 0;
+  const server = createServer((_request, response) => {
+    requests++;
+    response.setHeader('content-type', 'application/json');
+    response.end('[]');
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  t.after(() => new Promise(resolve => server.close(resolve)));
+
+  const result = await runLauncher(['--help'], { ...process.env, H2O_URL: `http://127.0.0.1:${server.address().port}`, NO_PROXY: '127.0.0.1' });
+  assert.equal(result.code, 0, result.stderr);
+  assert.equal(result.stderr, '');
+  assert.match(result.stdout, /Usage: sap-ai-dev/);
+  assert.match(result.stdout, /Use an MCP client to call server tools/);
+  assert.equal(requests, 0);
+});
+
+test('list-destinations JSON is redacted and probes through the BAS proxy', async () => {
+  const requests = [];
+  const server = createServer((request, response) => {
+    requests.push({ host: request.headers.host, path: request.url });
+    if (request.url === '/api/listDestinations') {
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify([{ Name: 'launch-system', WebIDEEnabled: true, 'HTML5.DynamicDestination': true, WebIDEUsage: 'dev_abap', Authentication: 'PrincipalPropagation', Password: 'do-not-print' }]));
+      return;
+    }
+    response.writeHead(403);
+    response.end();
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  const result = await runLauncher(['--list-destinations', '--json'], { ...process.env, H2O_URL: `http://127.0.0.1:${port}`, HTTP_PROXY: `http://127.0.0.1:${port}`, HTTPS_PROXY: `http://127.0.0.1:${port}`, NO_PROXY: '127.0.0.1' });
+  await new Promise(resolve => server.close(resolve));
+  assert.equal(result.code, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), [{ name: 'launch-system', client: '001', authentication: 'PrincipalPropagation', probe: 'auth-required' }]);
+  assert.deepEqual(requests, [
+    { host: `127.0.0.1:${port}`, path: '/api/listDestinations' },
+    { host: 'launch-system.dest', path: 'http://launch-system.dest/sap/bc/adt/discovery' }
+  ]);
+  assert.equal(result.stdout.includes('do-not-print'), false);
+});
+test('runtime starts destinations even when their ADT probes fail', async () => {
+  const server = createServer((request, response) => {
+    if (request.url.includes('/api/listDestinations')) {
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify([{ Name: 'launch-system', WebIDEEnabled: true, 'HTML5.DynamicDestination': true, WebIDEUsage: 'dev_abap' }]));
+      return;
+    }
+    response.writeHead(503);
+    response.end();
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const proxy = `http://127.0.0.1:${server.address().port}`;
+  try {
+    const result = await runLauncher([], {
+      ...process.env,
+      BAS_VSP_BINARY: fakeVsp,
+      H2O_URL: 'http://bas.example',
+      BAS_VSP_DESTINATION: 'launch-system',
+      HTTP_PROXY: proxy,
+      http_proxy: proxy,
+      NO_PROXY: '',
+      no_proxy: ''
+    });
+    assert.equal(result.code, 0, result.stderr);
+    assert.equal(result.stdout, '');
+    assert.match(result.stderr, /launch-system: probe=unavailable \(HTTP 503\)/);
+    assert.match(result.stderr, /starting MCP proxy for launch-system \(client=001\)/);
+    assert.match(result.stderr, /\[launch-system\] starting VSP child/);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+test('setup subprocess writes one isolated MCP entry per selected destination', async () => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-launcher-setup-'));
+  const config = join(directory, 'mcp.json');
+  await writeFile(config, JSON.stringify({ inputs: [], servers: { unrelated: { type: 'stdio', command: 'other' } } }));
+  const server = createServer((request, response) => {
+    if (request.url === '/api/listDestinations') {
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify([
+        { Name: 'alpha-system', WebIDEEnabled: true, 'HTML5.DynamicDestination': true, WebIDEUsage: 'dev_abap', 'SAP-Client': '100' },
+        { Name: 'beta-system', WebIDEEnabled: true, 'HTML5.DynamicDestination': true, WebIDEUsage: 'dev_abap', 'SAP-Client': '200' }
+      ]));
+      return;
+    }
+    response.writeHead(404);
+    response.end();
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const env = { ...process.env, H2O_URL: `http://127.0.0.1:${server.address().port}`, BAS_VSP_SKIP_PROBE: 'true', BAS_VSP_MCP_CONFIG: config };
+  try {
+    const first = await runLauncherTty(env, 'a\r', ['--setup', '--npx']);
+    assert.equal(first.code, 0, `${first.stdout}\n${first.stderr}`);
+    let current = JSON.parse(await readFile(config, 'utf8'));
+    let generated = Object.entries(current.servers).filter(([, entry]) => entry.BAS_EXT === 'true');
+    assert.deepEqual(generated.map(([, entry]) => entry.env.BAS_VSP_DESTINATION), ['alpha-system', 'beta-system'], `${first.stdout}\n${first.stderr}`);
+    assert.equal(generated.every(([, entry]) => entry.env.H2O_URL === env.H2O_URL), true);
+    const packageJson = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+    assert.deepEqual(generated.map(([, entry]) => [entry.command, entry.args]), [
+      ['npx', ['--yes', '--ignore-scripts', `--package=sap-ai-dev-toolkit@${packageJson.version}`, 'sap-ai-dev']],
+      ['npx', ['--yes', '--ignore-scripts', `--package=sap-ai-dev-toolkit@${packageJson.version}`, 'sap-ai-dev']]
+    ]);
+    const second = await runLauncherTty(env, '\r', ['--setup', '--npx']);
+    assert.equal(second.code, 0, `${second.stdout}\\n${second.stderr}`);
+    current = JSON.parse(await readFile(config, 'utf8'));
+    generated = Object.keys(current.servers).filter(name => name !== 'unrelated');
+    assert.deepEqual(generated, []);
+    assert.deepEqual(current.servers.unrelated, { type: 'stdio', command: 'other' });
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
+test('non-BAS list mode reports the required discovery boundary', async () => {
+  const result = await runLauncher(['--list-destinations', '--json'], { ...process.env, H2O_URL: '' });
+  assert.equal(result.code, 1);
+  assert.match(result.stderr, /H2O_URL is required/);
+});

package/test/mcp-config-cf.test.mjs

@@ -0,0 +1,149 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { buildMcpEntries, buildSapDevelopmentMcpEntries, collectCloudFoundryKeyReferencesFromAllEntries, collectManagedCloudFoundryKeyReferences, installMcpConfig, readMcpConfig } from '../src/mcp-config.mjs';
+
+const bas = {
+  source: 'bas', name: 'shared', serverName: 'shared', url: 'http://shared.dest',
+  client: '001', authentication: 'NoAuthentication', probe: { status: 'available', available: true }
+};
+
+function cfDestination(spaceGuid, destinationInstanceGuid, keyName, proxyType = 'Internet') {
+  return {
+    source: 'cloud-foundry',
+    name: 'shared',
+    serverName: `cf:${spaceGuid}:${destinationInstanceGuid}:shared`,
+    client: '100',
+    authentication: 'BasicAuthentication',
+    proxyType,
+    probe: { status: 'auth-required', available: true },
+    cf: {
+      spaceGuid,
+      destinationInstanceGuid,
+      destinationInstanceName: `destination-${destinationInstanceGuid}`,
+      destinationKeyName: keyName,
+      ...(proxyType === 'OnPremise' ? {
+        connectivityInstanceGuid: 'connectivity-guid',
+        connectivityInstanceName: 'connectivity-service',
+        connectivityKeyName: 'connectivity-key'
+      } : {})
+    }
+  };
+}
+
+test('writes source-qualified CF entries beside same-named BAS destinations', () => {
+  const first = cfDestination('space-one', 'instance-one', 'key-one');
+  const second = cfDestination('space-one', 'instance-two', 'key-two');
+  const entries = buildMcpEntries([bas, first, second], { H2O_URL: 'http://h2o.example' });
+  assert.deepEqual(Object.keys(entries).sort(), [
+    'cf:space-one:instance-one:shared',
+    'cf:space-one:instance-two:shared',
+    'shared'
+  ]);
+  assert.deepEqual(entries['cf:space-one:instance-one:shared'].env, {
+    H2O_URL: 'http://h2o.example',
+    SAP_ALLOW_TRANSPORTABLE_EDITS: 'true',
+    BAS_VSP_DESTINATION_SOURCE: 'cloud-foundry',
+    BAS_VSP_DESTINATION: 'shared',
+    BAS_CF_SPACE_GUID: 'space-one',
+    BAS_CF_DESTINATION_INSTANCE_GUID: 'instance-one',
+    BAS_CF_DESTINATION_INSTANCE: 'destination-instance-one',
+    BAS_CF_DESTINATION_KEY: 'key-one',
+    BAS_CF_DESTINATION_NAME: 'shared'
+  });
+  assert.equal(entries.shared.env.BAS_VSP_DESTINATION, 'shared');
+  assert.equal(JSON.stringify(entries).includes('shared.dest'), false);
+  assert.equal(JSON.stringify(entries).includes('Password'), false);
+
+  const onPremise = buildMcpEntries([cfDestination('space-one', 'onprem-instance', 'destination-key', 'OnPremise')], { H2O_URL: 'http://h2o.example' });
+  assert.equal(onPremise['cf:space-one:onprem-instance:shared'].env.BAS_CF_CONNECTIVITY_KEY, 'connectivity-key');
+});
+
+test('extracts key references only from package-managed Cloud Foundry entries', () => {
+  const cloudFoundry = buildMcpEntries([
+    cfDestination('space-one', 'instance-one', 'destination-key', 'OnPremise')
+  ], { H2O_URL: 'http://h2o.example' })['cf:space-one:instance-one:shared'];
+  const managedNpx = {
+    ...cloudFoundry,
+    command: 'npx',
+    args: ['--yes', '--package=sap-ai-dev-toolkit@0.1.0', 'sap-ai-dev']
+  };
+  const config = { servers: {
+    first: cloudFoundry,
+    duplicate: managedNpx,
+    unmanaged: { ...cloudFoundry, BAS_EXT: undefined },
+    otherPackage: { ...cloudFoundry, command: 'other' },
+    otherSource: { ...cloudFoundry, env: { ...cloudFoundry.env, BAS_VSP_DESTINATION_SOURCE: 'bas' } }
+  } };
+  assert.deepEqual(collectManagedCloudFoundryKeyReferences(config), [
+    { kind: 'destination', spaceGuid: 'space-one', instanceGuid: 'instance-one', instanceName: 'destination-instance-one', keyName: 'destination-key' },
+    { kind: 'connectivity', spaceGuid: 'space-one', instanceGuid: 'connectivity-guid', instanceName: 'connectivity-service', keyName: 'connectivity-key' }
+  ]);
+  const userConfig = { servers: {
+    customServer: { command: 'custom-launcher', env: { ...cloudFoundry.env, BAS_VSP_DESTINATION_SOURCE: undefined } },
+    noEnvironment: { command: 'custom-launcher' }
+  } };
+  assert.deepEqual(collectCloudFoundryKeyReferencesFromAllEntries(userConfig), [
+    { kind: 'destination', spaceGuid: 'space-one', instanceGuid: 'instance-one', instanceName: 'destination-instance-one', keyName: 'destination-key' },
+    { kind: 'connectivity', spaceGuid: 'space-one', instanceGuid: 'connectivity-guid', instanceName: 'connectivity-service', keyName: 'connectivity-key' }
+  ]);
+});
+
+test('builds SAP development companion MCP entries', () => {
+  const entries = buildSapDevelopmentMcpEntries(['sap-fiori-tools', 'ui5-tools']);
+  assert.deepEqual(Object.keys(entries), ['sap-fiori-tools', 'ui5-tools']);
+  assert.deepEqual(entries['sap-fiori-tools'].args, ['--yes', '--package=@sap-ux/fiori-mcp-server', 'fiori-mcp']);
+  assert.equal(entries['ui5-tools'].command, 'npx');
+  assert.equal(entries['ui5-tools'].BAS_EXT_KIND, 'sap-development-companion');
+  assert.throws(() => buildSapDevelopmentMcpEntries(['missing-tool']), /Unknown SAP development MCP server id/);
+});
+
+test('installs and removes SAP development companion entries', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-mcp-tools-config-'));
+  const path = join(directory, 'mcp.json');
+  await writeFile(path, JSON.stringify({ servers: { userServer: { type: 'stdio', command: 'custom-server' } } }));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+
+  const result = await installMcpConfig([], {
+    env: { H2O_URL: 'http://h2o.example' },
+    path,
+    sapDevelopmentServers: ['sap-fiori-tools', 'cap-tools']
+  });
+  assert.deepEqual(Object.keys(result.servers).sort(), ['cap-tools', 'sap-fiori-tools']);
+  const written = await readMcpConfig(path);
+  assert.deepEqual(Object.keys(written.servers).sort(), ['cap-tools', 'sap-fiori-tools', 'userServer']);
+
+  await installMcpConfig([], { env: { H2O_URL: 'http://h2o.example' }, path });
+  const cleared = await readMcpConfig(path);
+  assert.deepEqual(Object.keys(cleared.servers), ['userServer']);
+});
+
+test('installs and removes CF entries without deleting unrelated MCP servers', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-mcp-cf-config-'));
+  const path = join(directory, 'mcp.json');
+  await writeFile(path, JSON.stringify({
+    unrelated: true,
+    servers: { userServer: { type: 'stdio', command: 'custom-server' } }
+  }));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+
+  const result = await installMcpConfig([bas, cfDestination('space-one', 'instance-one', 'managed-key')], {
+    env: { H2O_URL: 'http://h2o.example' },
+    path,
+    command: 'npx',
+    args: ['--yes', '--package=sap-ai-dev-toolkit@0.1.0', 'sap-ai-dev']
+  });
+  assert.deepEqual(Object.keys(result.servers).sort(), ['cf:space-one:instance-one:shared', 'shared']);
+  const written = await readMcpConfig(path);
+  assert.equal(written.unrelated, true);
+  assert.deepEqual(Object.keys(written.servers).sort(), ['cf:space-one:instance-one:shared', 'shared', 'userServer']);
+  assert.deepEqual(collectManagedCloudFoundryKeyReferences(written), [
+    { kind: 'destination', spaceGuid: 'space-one', instanceGuid: 'instance-one', instanceName: 'destination-instance-one', keyName: 'managed-key' }
+  ]);
+
+  await installMcpConfig([], { env: { H2O_URL: 'http://h2o.example' }, path });
+  const cleared = JSON.parse(await readFile(path, 'utf8'));
+  assert.deepEqual(Object.keys(cleared.servers), ['userServer']);
+});

package/test/mcp-proxy.test.mjs

@@ -0,0 +1,337 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
+import { childArguments, MCPProxy } from '../src/mcp-proxy.mjs';
+import { PassThrough } from 'node:stream';
+
+const fixture = fileURLToPath(new URL('./fixtures/fake-vsp.mjs', import.meta.url));
+const REQUESTED_TOOLS = [
+  'AnalyzeABAPCode', 'AnalyzeCallGraph', 'CodeCompletion', 'GetAbapHelp',
+  'GetCallGraph', 'GetCalleesOf', 'GetCallersOf', 'GetCodeCoverage',
+  'GetConnectionInfo', 'GetObjectStructure', 'GetTypeHierarchy', 'GetTypeInfo',
+  'GrepObject', 'GrepPackage', 'CallRFC', 'DebuggerAttach', 'DebuggerDetach',
+  'DebuggerGetStack', 'DebuggerGetVariables', 'DebuggerListen', 'DebuggerStep',
+  'DeleteBreakpoint', 'GetBreakpoints', 'GetDump', 'GetSQLTraceState', 'GetTrace',
+  'ListDumps', 'SetBreakpoint', 'CloneObject', 'CreateAndActivateProgram',
+  'CreateClassWithTests', 'CreateObject', 'CreateTestInclude', 'DeleteObject',
+  'ExecuteABAP', 'GetClass', 'GetClassComponents', 'GetClassInclude', 'GetFunction',
+  'GetInclude', 'GetInterface', 'GetProgram', 'GetStructure', 'GetTransaction',
+  'LockObject', 'MoveObject', 'RecoverFailedCreate', 'RenameObject', 'SaveToFile',
+  'UnlockObject', 'UpdateClassInclude', 'UpdateSource', 'WriteClass', 'WriteProgram',
+  'CreateTransport', 'ListDependencies', 'PublishServiceBinding', 'UnpublishServiceBinding'
+];
+
+
+async function fixtureProxy(logger = () => {}) {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-vsp-test-'));
+  const log = join(directory, 'children.log');
+  const destinations = ['alpha', 'beta'].map(name => ({ name, url: `http://${name}.dest`, client: '001' }));
+  const proxy = new MCPProxy({ binary: fixture, destinations, env: { ...process.env, BAS_VSP_DESTINATION: 'alpha', BAS_VSP_MODE: 'expert', FAKE_LOG: log, SAP_ALLOW_TRANSPORTABLE_EDITS: 'true', SAP_USER: 'must-not-pass', SAP_PASSWORD: 'must-not-pass', Authorization: 'Bearer must-not-pass', Cookie: 'secret', SAP_READ_ONLY: 'true' }, log: logger });
+  proxy.start();
+  return { directory, log, proxy };
+}
+test('uses authentication-specific arguments for Cloud Foundry children', () => {
+  const bas = { name: 'bas', url: 'http://bas.dest', client: '001' };
+  assert.deepEqual(childArguments(bas, {}), [
+    '--url', 'http://bas.dest', '--client', '001', '--mode', 'expert', '--proxy-auth', '--enable-transports'
+  ]);
+  const noAuth = { source: 'cloud-foundry', name: 'internet', url: 'http://sap.example', client: '100', authentication: 'NoAuthentication' };
+  const basic = { ...noAuth, authentication: 'BasicAuthentication' };
+  const principal = { ...noAuth, proxyType: 'OnPremise', authentication: 'PrincipalPropagation' };
+  assert.equal(childArguments(noAuth, {}).includes('--proxy-auth'), false);
+  assert.equal(childArguments(basic, {}).includes('--proxy-auth'), false);
+  assert.equal(childArguments(principal, {}).includes('--proxy-auth'), true);
+});
+
+test('closes each Cloud Foundry route after child exit and on startup failure', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-cf-child-lifecycle-'));
+  const log = join(directory, 'children.log');
+  let closeCount = 0;
+  const destination = {
+    source: 'cloud-foundry',
+    name: 'runtime',
+    url: 'http://runtime.dest',
+    client: '001',
+    authentication: 'BasicAuthentication',
+    childEnv: { SAP_USER: 'destination-user', SAP_PASSWORD: 'destination-password', SAP_VERBOSE: 'false' },
+    async close() { closeCount += 1; }
+  };
+  const proxy = new MCPProxy({
+    binary: fixture,
+    destinations: [destination],
+    env: { ...process.env, FAKE_LOG: log, SAP_USER: 'parent-user', SAP_PASSWORD: 'parent-password' },
+    log: () => {}
+  });
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+  proxy.start();
+  const initialized = await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+  assert.ok(initialized.result);
+  const child = proxy.children[0].child;
+  const exit = once(child.process, 'exit');
+  child.process.kill('SIGTERM');
+  await exit;
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(closeCount, 1);
+  const event = (await readFile(log, 'utf8')).trim().split('\n').map(line => JSON.parse(line)).find(row => row.event === 'initialize');
+  assert.equal(event.argv.includes('--proxy-auth'), false);
+  assert.deepEqual([event.env.user, event.env.password, event.env.verbose], ['destination-user', 'destination-password', 'false']);
+  await proxy.close();
+  assert.equal(closeCount, 1);
+
+  let failedStartCloseCount = 0;
+  const failedProxy = new MCPProxy({
+    binary: fixture,
+    destinations: [{ ...destination, async close() { failedStartCloseCount += 1; } }],
+    spawn: () => { throw new Error('spawn denied'); },
+    log: () => {}
+  });
+  assert.throws(() => failedProxy.start(), /No destination child could be started/);
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(failedStartCloseCount, 1);
+});
+
+test('merges paged tools and routes calls to the selected child', async t => {
+  const { directory, log, proxy } = await fixtureProxy();
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+
+  const initialized = await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } });
+  assert.equal(initialized.result.serverInfo.name, 'alpha');
+  const listed = await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  const names = new Set(listed.result.tools.map(tool => tool.name));
+  const queryTool = listed.result.tools.find(tool => tool.name === 'beta__RunQuery');
+  assert.deepEqual(queryTool.inputSchema, {
+    type: 'object',
+    properties: { sql_query: { type: 'string' }, max_rows: { type: 'number' }, all_rows: { type: 'boolean' } },
+    required: ['sql_query']
+  });
+  assert.equal(queryTool.description, 'RunQuery [destination: beta]');
+  const lintTool = listed.result.tools.find(tool => tool.name === 'alpha__LintABAP');
+  assert.deepEqual(Object.keys(lintTool.inputSchema.properties).sort(), ['config', 'files']);
+  assert.deepEqual(lintTool.inputSchema.required, ['files']);
+  assert.deepEqual(lintTool.inputSchema.properties.files.items.required, ['filename', 'source']);
+
+  for (const destination of ['alpha', 'beta']) {
+    for (const toolName of REQUESTED_TOOLS) {
+      assert.ok(names.has(`${destination}__${toolName}`), `${destination} exposes ${toolName}`);
+    }
+    for (const coreTool of [
+      'GetSource', 'RunQuery', 'GetSystemInfo', 'GetInstalledComponents',
+      'GetFeatures', 'GetAPIReleaseState', 'PrettyPrint', 'ListTransports',
+      'GetTransport', 'GetUserTransports', 'GetTransportInfo',
+      'GetApplicationLog', 'ActivateMultiple'
+    ]) {
+      assert.ok(names.has(`${destination}__${coreTool}`), `${destination} exposes ${coreTool}`);
+    }
+    for (const formerlyExcludedTool of ['ListSQLTraces', 'ReleaseTransport', 'DeleteTransport', 'SAP']) {
+      assert.ok(names.has(`${destination}__${formerlyExcludedTool}`), `${destination} exposes ${formerlyExcludedTool}`);
+    }
+  }
+
+  const requiredArguments = {
+    GetFeatures: [],
+    GetAPIReleaseState: ['object_uri'],
+    PrettyPrint: ['source'],
+    ListTransports: [],
+    GetTransport: ['transport'],
+    GetUserTransports: [],
+    GetTransportInfo: ['object_url', 'dev_class'],
+    ActivateMultiple: ['objects'],
+    GetApplicationLog: []
+  };
+  for (const [toolName, required] of Object.entries(requiredArguments)) {
+    const tool = listed.result.tools.find(entry => entry.name === `alpha__${toolName}`);
+    assert.deepEqual(tool.inputSchema.required, required);
+  }
+  const applicationLog = listed.result.tools.find(entry => entry.name === 'alpha__GetApplicationLog');
+  assert.deepEqual(Object.keys(applicationLog.inputSchema.properties).sort(), [
+    'from', 'max_results', 'messages', 'object', 'program', 'subobject', 'to', 'user'
+  ]);
+
+  const read = await proxy.handle({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'beta__GetSource', arguments: { object: 'ZREAD' } } });
+  const write = await proxy.handle({ jsonrpc: '2.0', id: 4, method: 'tools/call', params: { name: 'alpha__WriteSource', arguments: { source: 'WRITE' } } });
+  const query = await proxy.handle({ jsonrpc: '2.0', id: 5, method: 'tools/call', params: { name: 'beta__RunQuery', arguments: { sql_query: 'SELECT * FROM T000' } } });
+  const system = await proxy.handle({ jsonrpc: '2.0', id: 6, method: 'tools/call', params: { name: 'alpha__GetSystemInfo', arguments: {} } });
+  assert.equal(read.result.content[0].text, 'beta:GetSource');
+  assert.equal(write.result.content[0].text, 'alpha:WriteSource');
+  assert.equal(query.result.content[0].text, 'beta:RunQuery');
+  assert.equal(system.result.content[0].text, 'alpha:GetSystemInfo');
+
+  const additionalCalls = [
+    ['GetFeatures', {}],
+    ['GetAPIReleaseState', { object_uri: '/sap/bc/adt/oo/classes/cl_abap_typedescr' }],
+    ['PrettyPrint', { source: 'WRITE / 1.' }],
+    ['ListTransports', {}],
+    ['GetTransport', { transport: 'A4HK900094' }],
+    ['GetUserTransports', { user_name: 'DEVUSER' }],
+    ['GetTransportInfo', { object_url: '/sap/bc/adt/oo/classes/zcl_demo', dev_class: 'ZPKG' }],
+    ['GetApplicationLog', {
+      program: 'ZDEMO_POST',
+      user: 'TESTUSER',
+      object: 'ZDEMO_LOG',
+      subobject: 'POST',
+      from: '2026-08-01',
+      to: '2026-08-31',
+      max_results: 20,
+      messages: true,
+      action: 'delete',
+      type: 'delete',
+      params: { type: 'delete' }
+    }],
+    ['ActivateMultiple', { objects: ['PROG ZDEMO'] }],
+    ['CreateTransport', {}],
+    ['ReleaseTransport', {}],
+    ['DeleteTransport', {}],
+    ['ListSQLTraces', {}],
+    ['SAP', { action: 'analyze', params: { type: 'application_log' } }]
+  ];
+  for (const [index, [name, arguments_]] of additionalCalls.entries()) {
+    const response = await proxy.handle({
+      jsonrpc: '2.0',
+      id: 7 + index,
+      method: 'tools/call',
+      params: { name: `alpha__${name}`, arguments: arguments_ }
+    });
+    assert.equal(response.result.content[0].text, name === 'GetApplicationLog' ? 'alpha:SAP' : `alpha:${name}`);
+  }
+
+  const entries = (await readFile(log, 'utf8')).trim().split('\n').map(line => JSON.parse(line));
+  const calls = entries.filter(entry => entry.event === 'call');
+  assert.deepEqual(calls.map(call => [call.destination, call.name]), [
+    ['beta', 'GetSource'], ['alpha', 'WriteSource'], ['beta', 'RunQuery'], ['alpha', 'GetSystemInfo'],
+    ...additionalCalls.map(([name]) => ['alpha', name === 'GetApplicationLog' ? 'SAP' : name])
+  ]);
+  assert.deepEqual(calls.map(call => call.arguments), [
+    { object: 'ZREAD' }, { source: 'WRITE' }, { sql_query: 'SELECT * FROM T000' }, {},
+    ...additionalCalls.map(([name, arguments_]) => name === 'GetApplicationLog'
+      ? {
+          action: 'analyze',
+          params: {
+            type: 'application_log',
+            program: arguments_.program,
+            user: arguments_.user,
+            object: arguments_.object,
+            subobject: arguments_.subobject,
+            from: arguments_.from,
+            to: arguments_.to,
+            max_results: arguments_.max_results,
+            messages: arguments_.messages
+          }
+        }
+      : arguments_)
+  ]);
+
+  for (const init of entries.filter(entry => entry.event === 'initialize')) {
+    assert.equal(init.env.guard, 'true');
+    assert.equal(init.env.authorization, undefined);
+    assert.equal(init.env.cookie, undefined);
+    assert.equal(init.env.user, undefined);
+    assert.equal(init.env.password, undefined);
+    assert.equal(init.env.allowTransportableEdits, 'true');
+  }
+});
+test('runs LintABAP locally and returns parser findings', async t => {
+  const { directory, log, proxy } = await fixtureProxy();
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+
+  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } });
+  const listed = await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  assert.ok(listed.result.tools.some(tool => tool.name === 'alpha__LintABAP'));
+  const called = await proxy.handle({
+    jsonrpc: '2.0',
+    id: 3,
+    method: 'tools/call',
+    params: {
+      name: 'alpha__LintABAP',
+      arguments: { files: [{ filename: 'zparser_error.prog.abap', source: 'blah blah.' }] }
+    }
+  });
+  assert.equal(called.result.isError, false);
+  const report = JSON.parse(called.result.content[0].text);
+  assert.equal(report.status, 'issues');
+  assert.ok(report.issues.some(issue =>
+    issue.rule === 'parser_error' &&
+    issue.filename === 'zparser_error.prog.abap' &&
+    issue.start.line === 1
+  ));
+
+  const entries = (await readFile(log, 'utf8')).trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
+  assert.equal(entries.some(entry => entry.event === 'call' && entry.name === 'LintABAP'), false);
+});
+test('exposes local lint when a destination tool listing fails', async t => {
+  const { directory, proxy } = await fixtureProxy();
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+
+  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+  const alpha = proxy.children.find(entry => entry.destination.name === 'alpha');
+  alpha.child.listTools = async () => { throw new Error('fixture tools/list failure'); };
+
+  const listed = await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  assert.ok(listed.result.tools.some(tool => tool.name === 'alpha__LintABAP'));
+  assert.equal(listed.result.tools.some(tool => tool.name === 'alpha__GetSource'), false);
+  const called = await proxy.handle({
+    jsonrpc: '2.0',
+    id: 3,
+    method: 'tools/call',
+    params: { name: 'alpha__LintABAP', arguments: { files: [{ filename: 'zparser_error.prog.abap', source: 'blah blah.' }] } }
+  });
+  assert.equal(called.result.isError, false);
+});
+
+test('returns JSON-RPC errors for unknown namespaces and logs child failures', async t => {
+  const logs = [];
+  const { directory, proxy } = await fixtureProxy(message => logs.push(message));
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+  await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  const unknown = await proxy.handle({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'missing__GetSource' } });
+  assert.equal(unknown.error.code, -32602);
+  const remoteError = await proxy.handle({ jsonrpc: '2.0', id: 4, method: 'tools/call', params: { name: 'alpha__GetSource', arguments: { object: 'RPC_ERROR' } } });
+  assert.equal(remoteError.error.code, -32042);
+  assert.ok(logs.some(message => message.includes('backend connection refused') && message.includes('password=[redacted]') && !message.includes('must-not-log')));
+  const toolError = await proxy.handle({ jsonrpc: '2.0', id: 5, method: 'tools/call', params: { name: 'beta__GetSource', arguments: { object: 'TOOL_ERROR' } } });
+  assert.equal(toolError.result.isError, true);
+  assert.ok(logs.some(message => message.includes('backend timeout') && message.includes('token=[redacted]') && !message.includes('must-not-log')));
+  const success = await proxy.handle({ jsonrpc: '2.0', id: 6, method: 'tools/call', params: { name: 'alpha__WriteSource', arguments: { source: 'must-not-log' } } });
+  assert.equal(success.result.content[0].text, 'alpha:WriteSource');
+  assert.ok(logs.some(message => /\[alpha\] tools\/call WriteSource completed in \d+ms/.test(message)));
+  assert.equal(logs.some(message => message.includes('must-not-log')), false);
+  const child = proxy.children.find(entry => entry.destination.name === 'alpha').child;
+  child.process.kill('SIGKILL');
+  await new Promise(resolve => setTimeout(resolve, 25));
+  const failed = await proxy.handle({ jsonrpc: '2.0', id: 7, method: 'tools/call', params: { name: 'alpha__GetSource' } });
+  assert.equal(failed.error.code, -32001);
+  assert.ok(logs.some(message => message.includes('alpha') && message.includes('tools/call GetSource failed')));
+});
+test('stdin EOF shuts down every child process and forwards child logs', async t => {
+  const { directory, log, proxy } = await fixtureProxy();
+  t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+  const input = new PassThrough();
+  const output = [];
+  const serving = proxy.serve(input, line => output.push(JSON.parse(line)));
+  input.end([
+    { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} },
+    { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} },
+    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'alpha__GetSource', arguments: { emitNotification: true } } }
+  ].map(message => JSON.stringify(message)).join('\n') + '\n');
+  await serving;
+  assert.ok(output.some(message => message.method === 'notifications/message' && message.params?.data === 'fixture log notification'));
+  const entries = (await readFile(log, 'utf8')).trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
+  assert.equal(entries.filter(entry => entry.event === 'initialize').length, 2);
+  assert.deepEqual([...new Set(entries.filter(entry => entry.event === 'term').map(entry => entry.destination))].sort(), ['alpha', 'beta']);
+});
+
+
+test('keeps healthy children when one destination fails initialization', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-vsp-test-'));
+  const log = join(directory, 'children.log');
+  const proxy = new MCPProxy({ binary: fixture, destinations: ['broken', 'healthy'].map(name => ({ name, url: `http://${name}.dest`, client: '001' })), env: { ...process.env, FAKE_LOG: log }, log: () => {} });
+  proxy.start();
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+  const listed = await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  assert.ok(listed.result.tools.every(tool => tool.name.startsWith('healthy__')));
+});