sap-ai-dev-toolkit 0.3.4 → 0.4.0

package/test/hana-config.test.mjs

@@ -0,0 +1,168 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { quoteHanaIdentifier, resolveHanaReadOnlyConfig } from '../src/hana-config.mjs';
+import { hanaConnectionOptions, HanaDatabase } from '../src/hana-database.mjs';
+
+const explicitEnv = {
+  HANA_RO_HOST: 'hana.example.test',
+  HANA_RO_PORT: '443',
+  HANA_RO_USER: 'INSPECTOR',
+  HANA_RO_PASSWORD: 'do-not-print-this',
+  HANA_RO_SCHEMA: 'HDI_CONTAINER_SCHEMA'
+};
+
+function vcapBinding(name, user = 'INSPECTOR') {
+  return {
+    name,
+    binding_name: name,
+    credentials: {
+      host: 'hana.example.test',
+      port: 443,
+      user,
+      password: 'vcap-secret-not-for-output',
+      schema: 'HDI_CONTAINER_SCHEMA',
+      hdi_user: 'HDI_DEPLOYER',
+      hdi_password: 'never-use-this'
+    }
+  };
+}
+
+test('resolves explicit read-only configuration and never disables TLS verification', () => {
+  const config = resolveHanaReadOnlyConfig(explicitEnv);
+  assert.equal(config.source, 'environment');
+  assert.equal(config.user, 'INSPECTOR');
+  assert.equal(config.password, 'do-not-print-this');
+  assert.equal(config.schema, 'HDI_CONTAINER_SCHEMA');
+  assert.equal(Object.isFrozen(config), true);
+  const options = hanaConnectionOptions(config);
+  assert.equal(options.encrypt, true);
+  assert.equal(options.sslValidateCertificate, true);
+  assert.equal(options.currentSchema, 'HDI_CONTAINER_SCHEMA');
+  assert.equal(options.pwd, 'do-not-print-this');
+});
+
+test('rejects incomplete explicit credentials instead of falling back to VCAP', () => {
+  assert.throws(() => resolveHanaReadOnlyConfig({
+    ...explicitEnv,
+    HANA_RO_PASSWORD: '',
+    VCAP_SERVICES: JSON.stringify({ hana: [vcapBinding('fallback')] })
+  }), /Explicit HANA read-only configuration is incomplete/);
+});
+
+test('resolves one selected HANA VCAP binding without using HDI deployment credentials', () => {
+  const config = resolveHanaReadOnlyConfig({
+    VCAP_SERVICES: JSON.stringify({ hana: [vcapBinding('inspection-binding')] }),
+    HANA_RO_BINDING: 'inspection-binding'
+  });
+  assert.equal(config.source, 'vcap-services');
+  assert.equal(config.bindingName, 'inspection-binding');
+  assert.equal(config.serviceName, 'hana');
+  assert.equal(config.user, 'INSPECTOR');
+  assert.equal(config.schema, 'HDI_CONTAINER_SCHEMA');
+  assert.equal(config.password, 'vcap-secret-not-for-output');
+});
+
+test('fails closed when VCAP contains multiple HANA bindings', () => {
+  const env = {
+    VCAP_SERVICES: JSON.stringify({ hana: [vcapBinding('first'), vcapBinding('second')] })
+  };
+  assert.throws(() => resolveHanaReadOnlyConfig(env), /Multiple HANA VCAP bindings/);
+  assert.equal(resolveHanaReadOnlyConfig({ ...env, HANA_RO_BINDING: 'second' }).bindingName, 'second');
+});
+
+test('rejects an HDI-deployer-only binding and does not disclose its credentials', () => {
+  const deployerOnly = {
+    name: 'deployer-only',
+    credentials: {
+      host: 'hana.example.test',
+      port: 443,
+      schema: 'HDI_CONTAINER_SCHEMA',
+      hdi_user: 'HDI_DEPLOYER',
+      hdi_password: 'never-use-this'
+    }
+  };
+  assert.throws(() => resolveHanaReadOnlyConfig({
+    VCAP_SERVICES: JSON.stringify({ hana: [deployerOnly] })
+  }), error => {
+    assert.match(error.message, /separate read-only binding/);
+    assert.doesNotMatch(error.message, /never-use-this/);
+    return true;
+  });
+});
+
+test('rejects a VCAP binding that aliases its read-only and deployment usernames', () => {
+  const binding = vcapBinding('aliased-binding', 'HDI_DEPLOYER');
+  assert.throws(() => resolveHanaReadOnlyConfig({
+    VCAP_SERVICES: JSON.stringify({ hana: [binding] })
+  }), /aliases its read-only and HDI deployment users/);
+});
+
+test('rejects bad host, port, missing schema, and missing VCAP configuration', () => {
+  assert.throws(() => resolveHanaReadOnlyConfig({ ...explicitEnv, HANA_RO_HOST: 'https://hana.example.test' }), /hostname/);
+  assert.throws(() => resolveHanaReadOnlyConfig({ ...explicitEnv, HANA_RO_PORT: '70000' }), /between 1 and 65535/);
+  assert.throws(() => resolveHanaReadOnlyConfig({ ...explicitEnv, HANA_RO_SCHEMA: '' }), /incomplete/);
+  assert.throws(() => resolveHanaReadOnlyConfig({}), /Set HANA_RO_\*/);
+});
+
+test('quotes identifiers by doubling embedded quotes and rejects control characters', () => {
+  assert.equal(quoteHanaIdentifier('A"B'), '"A""B"');
+  assert.throws(() => quoteHanaIdentifier('bad\nname'), /identifier is invalid/);
+});
+
+test('serializes database calls, passes bind values, and redacts native driver errors', async () => {
+  const calls = [];
+  let disconnects = 0;
+  const connection = {
+    connect(options, callback) {
+      calls.push({ type: 'connect', options });
+      callback(null);
+    },
+    exec(sql, params, options, callback) {
+      calls.push({ type: 'exec', sql, params, options });
+      if (sql === 'FAIL') callback(Object.assign(new Error('password=do-not-print-this'), { code: 'HY000' }));
+      else callback(null, [{ OK: true }]);
+    },
+    disconnect(callback) {
+      disconnects += 1;
+      callback(null);
+    }
+  };
+  const db = new HanaDatabase(connection, resolveHanaReadOnlyConfig(explicitEnv));
+  await db.connect();
+  assert.deepEqual(await db.query('SELECT ? FROM DUMMY', ['value']), [{ OK: true }]);
+  await assert.rejects(db.query('FAIL'), error => {
+    assert.equal(error.name, 'HanaDatabaseError');
+    assert.match(error.message, /HANA error HY000/);
+    assert.doesNotMatch(error.message, /do-not-print-this/);
+    return true;
+  });
+  assert.equal(calls[0].options.sslValidateCertificate, true);
+  assert.equal(calls[1].params[0], 'value');
+  assert.deepEqual(calls[1].options, {});
+  await db.close();
+  await db.close();
+  assert.equal(disconnects, 1);
+});
+
+test('times out a hung read, requests cancellation, and retires its connection', async () => {
+  let cancels = 0;
+  let disconnects = 0;
+  const connection = {
+    connect(_options, callback) { callback(null); },
+    exec() {},
+    cancel() { cancels += 1; },
+    disconnect(callback) { disconnects += 1; callback(null); }
+  };
+  const db = new HanaDatabase(connection, resolveHanaReadOnlyConfig(explicitEnv), { queryTimeoutMs: 5 });
+  await db.connect();
+  await assert.rejects(db.query('SELECT HANG FROM DUMMY'), error => {
+    assert.equal(error.name, 'HanaQueryTimeoutError');
+    assert.match(error.message, /time limit/);
+    assert.doesNotMatch(error.message, /do-not-print-this/);
+    return true;
+  });
+  assert.equal(cancels, 1);
+  assert.equal(disconnects, 1);
+  assert.equal(db.unusable, true);
+  await assert.rejects(db.query('SELECT 1 FROM DUMMY'), /not available/);
+});

package/test/hana-inspector-stdio.test.mjs

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+const serverScript = fileURLToPath(new URL('../src/hana-inspector.mjs', import.meta.url));
+
+test('standalone HANA MCP process lists tools through stdio without emitting secrets or diagnostics on stdout', async t => {
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [serverScript],
+    cwd: process.cwd(),
+    env: {
+      PATH: process.env.PATH || '',
+      HANA_RO_HOST: 'hana.example.test',
+      HANA_RO_PORT: '443',
+      HANA_RO_USER: 'INSPECTOR',
+      HANA_RO_PASSWORD: 'never-emit-this-secret',
+      HANA_RO_SCHEMA: 'HDI_SCHEMA'
+    },
+    stderr: 'pipe'
+  });
+  const client = new Client({ name: 'hana-stdio-smoke', version: '1.0.0' });
+  const stderr = transport.stderr;
+  let stderrText = '';
+  stderr?.setEncoding('utf8');
+  stderr?.on('data', chunk => { stderrText += chunk; });
+  t.after(async () => {
+    await client.close().catch(() => {});
+    await transport.close().catch(() => {});
+  });
+
+  await client.connect(transport);
+  const listed = await client.listTools();
+  assert.deepEqual(listed.tools.map(tool => tool.name).sort(), [
+    'hana_connection_info',
+    'hana_describe_object',
+    'hana_list_objects',
+    'hana_read_rows'
+  ]);
+  assert.equal(stderrText.includes('never-emit-this-secret'), false);
+  assert.equal(stderrText.includes('HANA_RO_PASSWORD='), false);
+});

package/test/hana-tools.test.mjs

@@ -0,0 +1,206 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { createHanaInspector } from '../src/hana-inspector.mjs';
+
+const env = {
+  HANA_RO_HOST: 'hana.example.test',
+  HANA_RO_PORT: '443',
+  HANA_RO_USER: 'INSPECTOR',
+  HANA_RO_PASSWORD: 'test-secret',
+  HANA_RO_SCHEMA: 'HDI_SCHEMA'
+};
+
+function fakeDatabase({ rowResult = [{ ID: 7, TITLE: 'Catalog item' }], columns: columnOverride } = {}) {
+  const calls = [];
+  let closed = false;
+  const columns = columnOverride || [
+    { COLUMN_NAME: 'ID', POSITION: 1, DATA_TYPE_NAME: 'INTEGER', LENGTH: 10, SCALE: 0, IS_NULLABLE: 'FALSE' },
+    { COLUMN_NAME: 'TITLE', POSITION: 2, DATA_TYPE_NAME: 'NVARCHAR', LENGTH: 80, SCALE: 0, IS_NULLABLE: 'TRUE' }
+  ];
+  return {
+    calls,
+    get closed() { return closed; },
+    async query(sql, values = []) {
+      calls.push({ sql, values });
+      if (sql.includes('CURRENT_SCHEMA')) return [{ CURRENT_SCHEMA: 'HDI_SCHEMA', CURRENT_USER: 'INSPECTOR' }];
+      if (sql.includes('FROM SYS.TABLES') && sql.includes('TABLE_NAME = ?')) {
+        return values[1] === 'BOOKS' ? [{ OBJECT_NAME: 'BOOKS' }] : [];
+      }
+      if (sql.includes('FROM SYS.VIEWS') && sql.includes('VIEW_NAME = ?')) {
+        return values[1] === 'BOOKS_VIEW' ? [{ OBJECT_NAME: 'BOOKS_VIEW' }] : [];
+      }
+      if (sql.includes('FROM SYS.TABLES') && sql.includes('ORDER BY TABLE_NAME')) return [{ OBJECT_NAME: 'BOOKS' }];
+      if (sql.includes('FROM SYS.VIEWS') && sql.includes('ORDER BY VIEW_NAME')) return [{ OBJECT_NAME: 'BOOKS_VIEW' }];
+      if (sql.includes('FROM SYS.TABLE_COLUMNS')) return columns;
+      if (sql.includes('FROM SYS.VIEW_COLUMNS')) return columns;
+      if (sql.startsWith('SELECT "')) return rowResult;
+      throw new Error(`Unexpected test SQL: ${sql}`);
+    },
+    async close() { closed = true; }
+  };
+}
+
+async function connectTestClient(t, database) {
+  const runtime = createHanaInspector({ env, databaseFactory: async () => database });
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  const client = new Client({ name: 'hana-test-client', version: '1.0.0' });
+  await runtime.server.connect(serverTransport);
+  await client.connect(clientTransport);
+  t.after(async () => {
+    await client.close().catch(() => {});
+    await runtime.close();
+  });
+  return { client, runtime };
+}
+
+function parseResult(response) {
+  assert.equal(response.isError, undefined, response.content?.[0]?.text);
+  return JSON.parse(response.content[0].text);
+}
+
+test('advertises only bounded, read-only HANA tools with no arbitrary SQL input', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+  const result = await client.listTools();
+  const tools = new Map(result.tools.map(tool => [tool.name, tool]));
+  assert.deepEqual([...tools.keys()].sort(), [
+    'hana_connection_info',
+    'hana_describe_object',
+    'hana_list_objects',
+    'hana_read_rows'
+  ]);
+  for (const tool of tools.values()) {
+    assert.equal(tool.annotations?.readOnlyHint, true);
+    assert.equal(tool.annotations?.destructiveHint, false);
+  }
+  const readRowsSchema = tools.get('hana_read_rows').inputSchema;
+  assert.ok(readRowsSchema.properties.objectName);
+  assert.ok(readRowsSchema.properties.columns);
+  assert.equal(readRowsSchema.properties.sql, undefined);
+  assert.equal(readRowsSchema.properties.schema, undefined);
+});
+
+test('returns connection identity and schema-scoped object/column metadata', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+
+  const identity = parseResult(await client.callTool({ name: 'hana_connection_info', arguments: {} }));
+  assert.equal(identity.currentSchema, 'HDI_SCHEMA');
+  assert.equal(identity.databaseUser, 'INSPECTOR');
+  assert.equal(identity.tls, 'enabled; certificate verification required');
+  assert.equal(JSON.stringify(identity).includes('test-secret'), false);
+
+  const objects = parseResult(await client.callTool({ name: 'hana_list_objects', arguments: { objectType: 'ALL', maxResults: 10 } }));
+  assert.deepEqual(objects.objects, [
+    { objectName: 'BOOKS', objectType: 'TABLE' },
+    { objectName: 'BOOKS_VIEW', objectType: 'VIEW' }
+  ]);
+  assert.ok(database.calls.every(call => call.values.every(value => value !== 'OTHER_SCHEMA')));
+
+  const description = parseResult(await client.callTool({ name: 'hana_describe_object', arguments: { objectName: 'BOOKS' } }));
+  assert.equal(description.schema, 'HDI_SCHEMA');
+  assert.deepEqual(description.columns.map(column => column.COLUMN_NAME), ['ID', 'TITLE']);
+});
+
+test('reads only catalog-verified columns with bound filters and a fixed HDI schema', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+  const response = parseResult(await client.callTool({
+    name: 'hana_read_rows',
+    arguments: {
+      objectName: 'BOOKS',
+      schema: 'OTHER_SCHEMA',
+      columns: ['ID', 'TITLE'],
+      filters: [{ column: 'ID', operator: 'gt', value: 4 }],
+      orderBy: { column: 'ID', direction: 'ASC' },
+      limit: 10
+    }
+  }));
+  assert.deepEqual(response.rows, [{ ID: 7, TITLE: 'Catalog item' }]);
+  const dataQuery = database.calls.find(call => call.sql.startsWith('SELECT "ID"'));
+  assert.ok(dataQuery);
+  assert.match(dataQuery.sql, /FROM "HDI_SCHEMA"\."BOOKS"/);
+  assert.doesNotMatch(dataQuery.sql, /OTHER_SCHEMA/);
+  assert.deepEqual(dataQuery.values, [4]);
+  assert.match(dataQuery.sql, /LIMIT 10$/);
+});
+
+test('binds hostile object names and rejects unknown columns without executing a data query', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+  const maliciousName = 'BOOKS"; DROP TABLE X;--';
+  const response = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: maliciousName, columns: ['ID'], limit: 1 }
+  });
+  assert.equal(response.isError, true);
+  assert.equal(database.calls.some(call => call.sql.includes('DROP TABLE')), false);
+  const lookup = database.calls.find(call => call.sql.includes('TABLE_NAME = ?'));
+  assert.deepEqual(lookup.values, ['HDI_SCHEMA', maliciousName]);
+
+  const invalidColumn = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['SECRET'], limit: 1 }
+  });
+  assert.equal(invalidColumn.isError, true);
+  assert.equal(database.calls.some(call => call.sql.startsWith('SELECT "SECRET"')), false);
+});
+
+test('bounds object and row limits and refuses oversized results', async t => {
+  const largeDatabase = fakeDatabase({ rowResult: [{ ID: 1, TITLE: 'x'.repeat(100_000) }] });
+  const { client } = await connectTestClient(t, largeDatabase);
+  const tooManyObjects = await client.callTool({
+    name: 'hana_list_objects',
+    arguments: { objectType: 'TABLE', maxResults: 201 }
+  });
+  assert.equal(tooManyObjects.isError, true);
+
+  const tooLarge = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['ID', 'TITLE'], limit: 1 }
+  });
+  assert.equal(tooLarge.isError, true);
+  assert.match(tooLarge.content[0].text, /too large to return safely/);
+  assert.ok(Buffer.byteLength(tooLarge.content[0].text) < 1000);
+});
+
+test('rejects unbounded or oversized column selections before fetching row data', async t => {
+  const database = fakeDatabase({ columns: [
+    { COLUMN_NAME: 'ID', POSITION: 1, DATA_TYPE_NAME: 'INTEGER', LENGTH: 10, SCALE: 0, IS_NULLABLE: 'FALSE' },
+    { COLUMN_NAME: 'BODY', POSITION: 2, DATA_TYPE_NAME: 'NCLOB', LENGTH: 0, SCALE: 0, IS_NULLABLE: 'TRUE' },
+    { COLUMN_NAME: 'WIDE', POSITION: 3, DATA_TYPE_NAME: 'NVARCHAR', LENGTH: 9000, SCALE: 0, IS_NULLABLE: 'TRUE' },
+    { COLUMN_NAME: 'API_KEY', POSITION: 4, DATA_TYPE_NAME: 'NVARCHAR', LENGTH: 128, SCALE: 0, IS_NULLABLE: 'TRUE' }
+  ] });
+  const { client } = await connectTestClient(t, database);
+
+  const lob = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['BODY'], limit: 1 }
+  });
+  assert.equal(lob.isError, true);
+  assert.match(lob.content[0].text, /LOB and binary columns are not supported/);
+
+  const oversized = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['WIDE'], limit: 1 }
+  });
+  assert.equal(oversized.isError, true);
+  assert.match(oversized.content[0].text, /safe row-width limit/);
+  const credential = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['API_KEY'], limit: 1 }
+  });
+  assert.equal(credential.isError, true);
+  assert.match(credential.content[0].text, /Credential-like columns/);
+  assert.equal(database.calls.some(call => ['BODY', 'WIDE', 'API_KEY'].some(name => call.sql.startsWith(`SELECT "${name}"`))), false);
+});
+
+test('closes the connected database when the server runtime closes', async t => {
+  const database = fakeDatabase();
+  const { client, runtime } = await connectTestClient(t, database);
+  await client.callTool({ name: 'hana_connection_info', arguments: {} });
+  await runtime.close();
+  assert.equal(database.closed, true);
+});

package/test/live-s4h.test.mjs

@@ -0,0 +1,202 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const launcher = fileURLToPath(new URL('../src/launcher.mjs', import.meta.url));
+const LIVE = /^(1|true|yes)$/iu.test(process.env.SAP_AI_DEV_LIVE_S4H || '');
+const DESTINATION = process.env.SAP_AI_DEV_LIVE_DESTINATION || 'S4H';
+const SLUG = process.env.SAP_AI_DEV_LIVE_DESTINATION_SLUG || DESTINATION.toLowerCase().replace(/[^a-z0-9_-]+/gu, '-');
+const REQUEST_TIMEOUT_MS = Number(process.env.SAP_AI_DEV_LIVE_TIMEOUT_MS || 45_000);
+
+async function readConfiguredServer() {
+  if (/^(0|false|no)$/iu.test(process.env.SAP_AI_DEV_LIVE_USE_MCP_CONFIG || '')) return null;
+  const candidates = [
+    process.env.SAP_AI_DEV_MCP_CONFIG,
+    process.env.BAS_VSP_MCP_CONFIG,
+    join(homedir(), '.vscode', 'data', 'User', 'mcp.json'),
+    join(homedir(), '.vscode-server', 'data', 'User', 'mcp.json'),
+    join(homedir(), '.code-server', 'data', 'User', 'mcp.json')
+  ].filter(Boolean);
+  for (const path of candidates) {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile(path, 'utf8'));
+    } catch {
+      continue;
+    }
+    const server = parsed?.servers?.[DESTINATION];
+    if (server?.command) return { path, server };
+  }
+  return null;
+}
+
+class StdioMcpClient {
+  constructor(command, args, env) {
+    this.child = spawn(command, args, { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    this.nextId = 1;
+    this.pending = new Map();
+    this.stdout = '';
+    this.stderr = '';
+    this.notifications = [];
+    this.child.stdout.setEncoding('utf8');
+    this.child.stderr.setEncoding('utf8');
+    this.child.stdout.on('data', chunk => this.#onStdout(chunk));
+    this.child.stderr.on('data', chunk => { this.stderr += chunk; });
+    this.child.on('exit', (code, signal) => {
+      const error = new Error(`MCP process exited (${code ?? signal})\n${this.stderr.slice(-4000)}`);
+      for (const pending of this.pending.values()) pending.reject(error);
+      this.pending.clear();
+    });
+  }
+
+  #onStdout(chunk) {
+    this.stdout += chunk;
+    let newline;
+    while ((newline = this.stdout.indexOf('\n')) >= 0) {
+      const line = this.stdout.slice(0, newline).trim();
+      this.stdout = this.stdout.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (error) {
+        for (const pending of this.pending.values()) pending.reject(new Error(`Invalid JSON-RPC line: ${line}`));
+        this.pending.clear();
+        return;
+      }
+      if (message.id === undefined || message.id === null) {
+        this.notifications.push(message);
+        continue;
+      }
+      const pending = this.pending.get(message.id);
+      if (!pending) continue;
+      this.pending.delete(message.id);
+      clearTimeout(pending.timeout);
+      if (message.error) pending.reject(Object.assign(new Error(message.error.message), { response: message }));
+      else pending.resolve(message.result);
+    }
+  }
+
+  request(method, params) {
+    const id = this.nextId++;
+    const payload = { jsonrpc: '2.0', id, method, ...(params === undefined ? {} : { params }) };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Timed out waiting for ${method}\n${this.stderr.slice(-4000)}`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(id, { resolve, reject, timeout });
+      this.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    });
+  }
+
+  notify(method, params) {
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, ...(params === undefined ? {} : { params }) })}\n`);
+  }
+
+  async close() {
+    this.child.stdin.end();
+    this.child.kill('SIGTERM');
+    await Promise.race([
+      once(this.child, 'exit').catch(() => {}),
+      new Promise(resolve => setTimeout(resolve, 1500))
+    ]);
+    if (!this.child.killed) this.child.kill('SIGKILL');
+  }
+}
+
+function textPayload(result) {
+  return (result?.content || []).filter(item => item.type === 'text').map(item => item.text).join('\n');
+}
+
+async function withLiveClient(t) {
+  const configured = await readConfiguredServer();
+  const server = configured?.server;
+  const command = process.env.SAP_AI_DEV_LIVE_COMMAND || server?.command || process.execPath;
+  const args = process.env.SAP_AI_DEV_LIVE_COMMAND
+    ? (process.env.SAP_AI_DEV_LIVE_ARGS ? JSON.parse(process.env.SAP_AI_DEV_LIVE_ARGS) : [])
+    : (server?.command ? (server.args || []) : [launcher]);
+  const client = new StdioMcpClient(command, args, {
+    ...process.env,
+    ...(server?.env || {}),
+    SAP_AI_DEV_TOOLKIT_DESTINATION: server?.env?.SAP_AI_DEV_TOOLKIT_DESTINATION || DESTINATION,
+    SAP_AI_DEV_TOOLKIT_MODE: process.env.SAP_AI_DEV_TOOLKIT_MODE || server?.env?.SAP_AI_DEV_TOOLKIT_MODE || 'expert',
+    SAP_ALLOW_TRANSPORTABLE_EDITS: process.env.SAP_ALLOW_TRANSPORTABLE_EDITS || server?.env?.SAP_ALLOW_TRANSPORTABLE_EDITS || 'true'
+  });
+  t.after(() => client.close());
+  const initialized = await client.request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'sap-ai-dev-live-test', version: '1.0.0' } });
+  client.notify('notifications/initialized');
+  assert.equal(initialized.serverInfo.name, DESTINATION);
+  return client;
+}
+
+test('live S4H MCP exposes a curated ABAP lifecycle surface under 60 tools', { skip: LIVE ? false : 'set SAP_AI_DEV_LIVE_S4H=1 to run against a live BAS/S4H destination' }, async t => {
+  const client = await withLiveClient(t);
+  const listed = await client.request('tools/list', {});
+  const tools = listed.tools || [];
+  const names = new Set(tools.map(tool => tool.name));
+  const prefix = `${SLUG}__`;
+
+  assert.ok(tools.length > 25, `expected a useful ABAP lifecycle surface, got ${tools.length}`);
+  assert.ok(tools.length < 60, `curated destination tool count must stay below 60, got ${tools.length}`);
+  assert.ok(tools.every(tool => tool.name.startsWith(prefix)), 'every tool is destination-prefixed for the selected S4H server');
+
+  for (const required of [
+    'LintABAP', 'GetSystemInfo', 'GetConnectionInfo', 'GetFeatures',
+    'SearchObject', 'GrepObjects', 'GrepPackages', 'GetSource', 'WriteSource', 'EditSource', 'CompareSource',
+    'SyntaxCheck', 'PrettyPrint', 'Activate', 'RunUnitTests', 'RunATCCheck', 'GetInactiveObjects',
+    'GetClass', 'GetProgram', 'GetPackage', 'GetTable', 'GetTableContents', 'RunQuery',
+    'GetTransport', 'GetTransportInfo', 'ListTransports', 'CreateTransport',
+    'GetApplicationLog', 'PrepareABAPChangeSet', 'ApplyABAPChangeSet', 'CheckTransportReadiness', 'PlanABAPCloudMigration'
+  ]) {
+    assert.ok(names.has(`${prefix}${required}`), `expected curated lifecycle tool ${required}`);
+  }
+
+  for (const hidden of [
+    'SAP', 'ReleaseTransport', 'DeleteTransport', 'DeleteObject', 'ExecuteABAP', 'CallRFC',
+    'ListSQLTraces', 'AnalyzeABAPCode', 'CreateObject', 'CreateClassWithTests', 'WriteClass', 'UpdateSource'
+  ]) {
+    assert.equal(names.has(`${prefix}${hidden}`), false, `broad/destructive tool ${hidden} must remain hidden`);
+  }
+});
+
+test('live S4H MCP handles safe local and read-only SAP calls', { skip: LIVE ? false : 'set SAP_AI_DEV_LIVE_S4H=1 to run against a live BAS/S4H destination' }, async t => {
+  const client = await withLiveClient(t);
+  const prefix = `${SLUG}__`;
+  await client.request('tools/list', {});
+
+  const lint = await client.request('tools/call', {
+    name: `${prefix}LintABAP`,
+    arguments: { files: [{ filename: 'zlive_probe.prog.abap', source: "REPORT zlive_probe.\nWRITE / 'ok'.\n" }] }
+  });
+  const lintJson = JSON.parse(textPayload(lint));
+  assert.equal(lintJson.filesChecked, 1);
+
+  for (const [tool, args] of [
+    ['GetSystemInfo', {}],
+    ['GetConnectionInfo', {}],
+    ['GetFeatures', {}],
+    ['GetInstalledComponents', {}]
+  ]) {
+    const result = await client.request('tools/call', { name: `${prefix}${tool}`, arguments: args });
+    assert.notEqual(result.isError, true, `${tool} returned an MCP tool error: ${textPayload(result)}`);
+  }
+
+  const query = await client.request('tools/call', {
+    name: `${prefix}RunQuery`,
+    arguments: { sql_query: 'SELECT * FROM T000', max_rows: 1 }
+  });
+  assert.notEqual(query.isError, true, `RunQuery returned an MCP tool error: ${textPayload(query)}`);
+  assert.match(textPayload(query), /T000|MANDT|client|rows|\[/iu);
+
+  const appLog = await client.request('tools/call', {
+    name: `${prefix}GetApplicationLog`,
+    arguments: { max_results: 1 }
+  });
+  assert.notEqual(appLog.isError, true, `GetApplicationLog returned an MCP tool error: ${textPayload(appLog)}`);
+});

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

@@ -100,6 +100,17 @@ test('builds SAP development companion MCP entries', () => {
   assert.throws(() => buildSapDevelopmentMcpEntries(['missing-tool']), /Unknown SAP development MCP server id/);
 });
 
+test('configures the HANA inspector without persisting credentials', () => {
+  const entry = buildSapDevelopmentMcpEntries(['hana-cloud-inspector'])['hana-cloud-inspector'];
+  assert.equal(entry.command, 'npx');
+  assert.deepEqual(entry.args, ['--yes', '--ignore-scripts', '--package=sap-ai-dev-toolkit', 'sap-ai-hana']);
+  assert.equal(entry.BAS_EXT_KIND, 'sap-development-companion');
+  assert.equal(entry.displayName, 'HANA Cloud inspector');
+  assert.equal(entry.env, undefined);
+  assert.doesNotMatch(JSON.stringify(entry), /"(?:HANA_RO_PASSWORD|VCAP_SERVICES)"\s*:/);
+  assert.doesNotMatch(JSON.stringify(entry), /"(?:password|pwd)"\s*:/i);
+});
+
 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');
@@ -120,6 +131,35 @@ test('installs and removes SAP development companion entries', async t => {
   assert.deepEqual(Object.keys(cleared.servers), ['userServer']);
 });
 
+test('installs and removes the HANA inspector without changing unrelated MCP servers', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-mcp-hana-config-'));
+  const path = join(directory, 'mcp.json');
+  const initial = {
+    custom: true,
+    servers: { userServer: { type: 'stdio', command: 'custom-server' } }
+  };
+  await writeFile(path, JSON.stringify(initial));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+
+  const installed = await installMcpConfig([], {
+    env: { H2O_URL: 'http://h2o.example' },
+    path,
+    sapDevelopmentServers: ['hana-cloud-inspector']
+  });
+  assert.deepEqual(Object.keys(installed.servers), ['hana-cloud-inspector']);
+  const configured = await readMcpConfig(path);
+  assert.deepEqual(Object.keys(configured.servers).sort(), ['hana-cloud-inspector', 'userServer']);
+  assert.equal(configured.custom, true);
+  assert.equal(configured.servers['hana-cloud-inspector'].env, undefined);
+  assert.doesNotMatch(JSON.stringify(configured), /"(?:HANA_RO_PASSWORD|VCAP_SERVICES)"\s*:/);
+  assert.doesNotMatch(JSON.stringify(configured), /"(?:password|pwd)"\s*:/i);
+
+  await installMcpConfig([], { env: { H2O_URL: 'http://h2o.example' }, path });
+  const removed = await readMcpConfig(path);
+  assert.deepEqual(removed.servers, initial.servers);
+  assert.equal(removed.custom, true);
+});
+
 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');