sap-ai-dev-toolkit 0.3.0 → 0.3.3

package/test/copilot-content.test.mjs

@@ -56,6 +56,18 @@ function assertValidationPolicy(markdown, path) {
   assert.match(markdown, /report|Record|document/i, `${path} must require observed outcome reporting`);
 }
 
+function assertPlanFirstPolicy(markdown, path) {
+  assert.match(markdown, /[Pp]lan before implementing|[Pp]lanning phase before implementation/, `${path} must require a plan to be presented before implementation starts`);
+  assert.match(markdown, /wait for explicit (?:user )?approval|no SAP state-changing package proceeds before the user approves/i, `${path} must gate SAP state-changing implementation on explicit approval`);
+}
+
+function assertLocalFirstPolicy(markdown, path) {
+  assert.match(markdown, /abapGit[- ]serialized|abapGit-style/, `${path} must require local abapGit-style source files`);
+  assert.match(markdown, /object\.type\.extension/, `${path} must document the object.type.extension file naming`);
+  assert.match(markdown, /LintABAP/, `${path} must require local linting with LintABAP`);
+  assert.match(markdown, /before (?:they are )?sent to the SAP system|before sending to SAP|check and lint before sending/i, `${path} must require local checks before the SAP transfer`);
+}
+
 function assertNoUnsafeTransportClaims(markdown, path) {
   const releaseMentions = markdown.match(/ReleaseTransport|release\/deletion|release and deletion|release is unavailable|release action/gi) || [];
   assert.ok(releaseMentions.length > 0 || !/transport/i.test(markdown), `${path} transport guidance should explicitly handle release limitations when transport is discussed`);
@@ -88,6 +100,8 @@ test('ABAP Developer agent has valid metadata and invokes the packaged skills',
   }
   assertMentionsLiveToolDiscovery(markdown, agentPath);
   assertValidationPolicy(markdown, agentPath);
+  assertPlanFirstPolicy(markdown, agentPath);
+  assertLocalFirstPolicy(markdown, agentPath);
   assertNoUnsafeTransportClaims(markdown, agentPath);
 });
 
@@ -108,6 +122,24 @@ test('SAP Solution Architect agent has valid metadata and planning/handoff polic
   assert.match(markdown, /RAP Service Developer/i);
   assert.match(markdown, /ABAP Runtime Debugger/i);
   assert.match(markdown, /SDLC|lifecycle/i);
+  assertPlanFirstPolicy(markdown, path);
+  assertLocalFirstPolicy(markdown, path);
+  assertNoUnsafeTransportClaims(markdown, path);
+});
+
+test('RAP Service Developer agent has valid metadata and plan-first local-first policy', async () => {
+  const path = join(agentsRoot, 'rap-service-developer.agent.md');
+  const markdown = await readMarkdown(path);
+  const metadata = parseFrontmatter(markdown, path);
+  assert.deepEqual(Object.keys(metadata).sort(), ['description', 'name', 'target', 'user-invocable']);
+  assert.equal(metadata.name, 'RAP Service Developer');
+  assert.equal(metadata.target, 'vscode');
+  assert.equal(metadata['user-invocable'], 'true');
+  assert.match(metadata.description, /RAP/i);
+  assertMentionsLiveToolDiscovery(markdown, path);
+  assertValidationPolicy(markdown, path);
+  assertPlanFirstPolicy(markdown, path);
+  assertLocalFirstPolicy(markdown, path);
   assertNoUnsafeTransportClaims(markdown, path);
 });
 
@@ -134,6 +166,15 @@ test('implementation-oriented skills require tests, runtime evidence, activation
   }
 });
 
+test('implementation and delivery skills require planning first and local-first authoring', async () => {
+  for (const skill of ['abap-development', 'rap-development', 'rap-service-delivery', 'sap-sdlc-orchestration']) {
+    const path = join(skillsRoot, skill, 'SKILL.md');
+    const markdown = await readMarkdown(path);
+    assertPlanFirstPolicy(markdown, path);
+    assertLocalFirstPolicy(markdown, path);
+  }
+});
+
 test('debugging skill requires evidence before fixes and bounded debugger use', async () => {
   const path = join(skillsRoot, 'abap-debugging', 'SKILL.md');
   const markdown = await readMarkdown(path);

package/test/credentials-store.test.mjs

@@ -0,0 +1,156 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import http from 'node:http';
+import { request as httpRequest } from 'node:http';
+import { createBasDestinationRelay } from '../src/bas-destination-relay.mjs';
+import { readCredentials, removeDestinationCredentials, resolveCredentialsPath, storeDestinationCredentials } from '../src/credentials-store.mjs';
+
+const UNSAFE_METHODS = ['POST', 'PUT', 'PATCH', 'DELETE'];
+
+// SAP-like backend that requires Basic auth AND token+cookie pairing —
+// the semantics that only work when the relay connects directly.
+function authedBackend({ expectedUser = 'DEVELOPER', expectedPassword = 'secret123' } = {}) {
+  const state = { sessionCounter: 0, requests: [] };
+  const server = http.createServer((req, res) => {
+    state.requests.push({ method: req.method, headers: { ...req.headers } });
+    const authorization = String(req.headers.authorization || '');
+    const basic = authorization.replace(/^Basic /i, '');
+    const [user, password] = Buffer.from(basic, 'base64').toString().split(':');
+    if (user !== expectedUser || password !== expectedPassword) {
+      res.writeHead(401, { 'www-authenticate': 'Basic' });
+      res.end('credentials required');
+      return;
+    }
+    if (req.method === 'GET' && req.headers['x-csrf-token'] === 'Fetch') {
+      state.sessionCounter += 1;
+      res.writeHead(200, {
+        'x-csrf-token': `token-${state.sessionCounter}`,
+        'set-cookie': [`sap-session-${state.sessionCounter}=s${state.sessionCounter}; path=/`]
+      });
+      res.end('<ok/>');
+      return;
+    }
+    if (UNSAFE_METHODS.includes(req.method)) {
+      const match = String(req.headers['x-csrf-token'] || '').match(/^token-(\d+)$/);
+      const valid = match && String(req.headers.cookie || '').includes(`sap-session-${match[1]}=`);
+      if (!valid) {
+        res.writeHead(403, { 'x-csrf-token': 'Required' });
+        res.end('CSRF token validation failed');
+        return;
+      }
+      res.writeHead(201);
+      res.end('<created/>');
+      return;
+    }
+    res.writeHead(200);
+    res.end('<read/>');
+  });
+  return { state, server };
+}
+
+function relayFetch(relayUrl, path, options = {}) {
+  const target = new URL(path, relayUrl);
+  return new Promise((resolve, reject) => {
+    const req = httpRequest(target, { method: options.method || 'GET', headers: options.headers || {} }, response => {
+      let body = '';
+      response.setEncoding('utf8');
+      response.on('data', chunk => { body += chunk; });
+      response.on('end', () => resolve({ status: response.statusCode, body }));
+    });
+    req.on('error', reject);
+    if (options.body) req.write(options.body);
+    req.end();
+  });
+}
+
+test('credentials file resolves next to the MCP config and stores entries with 0600', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-creds-'));
+  t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+  const mcpConfig = join(directory, 'mcp.json');
+  const path = await resolveCredentialsPath({ HOME: '/nonexistent' }, mcpConfig);
+  assert.equal(path, join(directory, 'sap-ai-dev-toolkit-credentials.json'));
+
+  await storeDestinationCredentials(path, 'S4H', { host: 'https://backend.example:44300', user: 'DEVELOPER', password: 'secret123' });
+  const stored = await readCredentials(path);
+  assert.equal(stored.destinations.S4H.user, 'DEVELOPER');
+  assert.equal(stored.destinations.S4H.host, 'https://backend.example:44300');
+  const permissions = (await stat(path)).mode & 0o777;
+  assert.equal(permissions, 0o600, 'credentials file must be owner-only');
+
+  const raw = JSON.parse(await readFile(path, 'utf8'));
+  assert.equal(raw.version, 1);
+  assert.ok(Object.hasOwn(raw.destinations, 'S4H'));
+
+  const { removed } = await removeDestinationCredentials(path, ['S4H']);
+  assert.deepEqual(removed, ['S4H']);
+  assert.equal((await readCredentials(path)).destinations.S4H, undefined);
+});
+
+test('credentials file with malformed entries keeps only complete records', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-creds-bad-'));
+  t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+  const path = join(directory, 'sap-ai-dev-toolkit-credentials.json');
+  await writeFile(path, JSON.stringify({
+    version: 1,
+    destinations: {
+      GOOD: { host: 'https://good.example', user: 'u', password: 'p', updatedAt: '2026-01-01T00:00:00.000Z' },
+      NO_PASSWORD: { host: 'https://bad.example', user: 'u' },
+      NOT_OBJECT: 'nope'
+    }
+  }));
+  const stored = await readCredentials(path);
+  assert.deepEqual(Object.keys(stored.destinations), ['GOOD']);
+});
+
+test('relay direct connect sends Basic auth and CSRF pairing succeeds', async t => {
+  const { state, server } = authedBackend();
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const backendUrl = `http://127.0.0.1:${server.address().port}`;
+  const relay = createBasDestinationRelay(
+    {
+      name: 'S4H',
+      url: 'http://S4H.dest',
+      authentication: 'BasicAuthentication',
+      credentials: { host: backendUrl, user: 'DEVELOPER', password: 'secret123' }
+    },
+    { env: { HTTP_PROXY: '' }, log: () => {} }
+  );
+  const relayUrl = await relay.ready;
+  t.after(async () => { await relay.close(); await new Promise(resolve => server.close(resolve)); });
+  try {
+    const read = await relayFetch(relayUrl, '/sap/bc/adt/discovery');
+    assert.equal(read.status, 200, 'authenticated read must succeed');
+    const write = await relayFetch(relayUrl, '/sap/bc/adt/datapreview/freestyle', { method: 'POST', body: '<q/>' });
+    assert.equal(write.status, 201, `CSRF-protected write must succeed, got ${write.status}: ${write.body}`);
+    const post = state.requests.find(request => request.method === 'POST');
+    assert.match(post.headers.authorization, /^Basic /);
+    assert.match(String(post.headers.cookie), /sap-session-\d+=/);
+    assert.equal(relay.stats.direct, true);
+  } finally {
+    void relayUrl;
+  }
+});
+
+test('relay direct connect with wrong credentials surfaces 401 without retries', async t => {
+  const { state, server } = authedBackend();
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const backendUrl = `http://127.0.0.1:${server.address().port}`;
+  const relay = createBasDestinationRelay(
+    {
+      name: 'S4H',
+      url: 'http://S4H.dest',
+      authentication: 'BasicAuthentication',
+      credentials: { host: backendUrl, user: 'DEVELOPER', password: 'wrong' }
+    },
+    { env: { HTTP_PROXY: '' }, log: () => {} }
+  );
+  const relayUrl = await relay.ready;
+  t.after(async () => { await relay.close(); await new Promise(resolve => server.close(resolve)); });
+  const write = await relayFetch(relayUrl, '/sap/bc/adt/datapreview/freestyle', { method: 'POST', body: '<q/>' });
+  assert.equal(write.status, 401);
+  assert.equal(relay.stats.csrfRetries, 0, '401 without a session must not trigger CSRF retries');
+  void state;
+});

package/test/discovery.test.mjs

@@ -10,7 +10,7 @@ test('normalizes destination metadata case-insensitively', () => {
   });
   assert.deepEqual(destination, {
     name: 'DEV-ABAP', authentication: 'PrincipalPropagation', client: '200',
-    url: 'http://DEV-ABAP.dest', rawKeys: ['Name', 'Properties']
+    url: 'http://DEV-ABAP.dest', backendUrl: 'https://backend.example', proxyType: null, rawKeys: ['Name', 'Properties']
   });
 });
 

package/test/mcp-proxy.test.mjs

@@ -47,6 +47,57 @@ test('uses authentication-specific arguments for Cloud Foundry children', () =>
   assert.equal(childArguments(principal, {}).includes('--proxy-auth'), true);
 });
 
+test('self-heals BAS destinations through a local destination relay without credentials', async t => {
+  const destination = { name: 'S4H', url: 'http://S4H.dest', client: '100', authentication: 'BasicAuthentication', proxyType: 'Internet' };
+  const directory = await mkdtemp(join(tmpdir(), 'bas-relay-'));
+  const log = join(directory, 'children.log');
+  const logs = [];
+  const proxy = new MCPProxy({ binary: fixture, destinations: [destination], env: { ...process.env, FAKE_LOG: log }, log: message => logs.push(message) });
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+  proxy.start();
+  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+  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'), true);
+  assert.match(event.argv[event.argv.indexOf('--url') + 1], /^http:\/\/127\.0\.0\.1:\d+$/);
+  assert.equal(event.env.user, undefined);
+  assert.equal(event.env.password, undefined);
+  assert.ok(logs.some(message => message.includes('BAS destination relay enabled')));
+});
+
+test('self-heals BAS relay children with loopback NO_PROXY and keeps --proxy-auth', async t => {
+  const destination = { name: 'S4H', url: 'http://S4H.dest', client: '100', authentication: 'BasicAuthentication', proxyType: 'Internet' };
+  const directory = await mkdtemp(join(tmpdir(), 'bas-relay-env-'));
+  const log = join(directory, 'children.log');
+  const proxy = new MCPProxy({ binary: fixture, destinations: [destination], env: { ...process.env, FAKE_LOG: log }, log: () => {} });
+  t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
+  proxy.start();
+  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+  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'), true);
+  const noProxy = String(event.env.noProxy || '').split(',').map(value => value.trim().toLowerCase());
+  assert.ok(noProxy.includes('127.0.0.1'), `NO_PROXY must exempt the relay loopback: ${event.env.noProxy}`);
+  assert.ok(noProxy.includes('localhost'), `NO_PROXY must exempt relay localhost: ${event.env.noProxy}`);
+});
+
+test('restarts a crashed VSP child and retries the tool call once', 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' } });
+  await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  const entry = proxy.children[0];
+  const originalChild = entry.child;
+  // Kill the child behind the proxy's back to simulate a crash.
+  const exit = once(originalChild.process, 'exit');
+  originalChild.process.kill('SIGKILL');
+  await exit;
+  const response = await proxy.handle({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'alpha__GetSystemInfo', arguments: {} } });
+  assert.equal(response?.error, undefined, `self-healing must recover the call: ${JSON.stringify(response?.error)}`);
+  assert.notEqual(proxy.children[0].child, originalChild, 'a replacement child must have been spawned');
+  const events = (await readFile(log, 'utf8')).trim().split('\n').map(line => JSON.parse(line));
+  assert.ok(events.some(row => row.event === 'initialize' && row.destination === 'alpha'), 'replacement child must re-initialize');
+  assert.ok(events.some(row => row.event === 'call' && row.name === 'GetSystemInfo'), 'the retried call must reach the child');
+});
+
 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');
@@ -89,7 +140,8 @@ test('closes each Cloud Foundry route after child exit and on startup failure',
     spawn: () => { throw new Error('spawn denied'); },
     log: () => {}
   });
-  assert.throws(() => failedProxy.start(), /No destination child could be started/);
+  failedProxy.start();
+  await assert.rejects(() => failedProxy.starting, /No destination child could be started/);
   await new Promise(resolve => setImmediate(resolve));
   assert.equal(failedStartCloseCount, 1);
 });
@@ -302,9 +354,13 @@ test('returns JSON-RPC errors for unknown namespaces and logs child failures', a
   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);
+  // A crashed child no longer fails the call: self-healing restarts it and
+  // retries once, so the request goes through to a fresh child.
+  const healed = await proxy.handle({ jsonrpc: '2.0', id: 7, method: 'tools/call', params: { name: 'alpha__GetSource' } });
+  assert.equal(healed?.error, undefined, `call must heal after child crash: ${JSON.stringify(healed?.error)}`);
+  assert.equal(healed.result.content[0].text, 'alpha:GetSource');
   assert.ok(logs.some(message => message.includes('alpha') && message.includes('tools/call GetSource failed')));
+  assert.ok(logs.some(message => message.includes('self-healing restart complete')), 'restart must be logged');
 });
 test('stdin EOF shuts down every child process and forwards child logs', async t => {
   const { directory, log, proxy } = await fixtureProxy();