sap-ai-dev-toolkit 0.6.5 → 0.6.7

package/scripts/postinstall.mjs

@@ -4,11 +4,11 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { installBinary } from '../src/binary.mjs';
 import { runSetup } from '../src/setup.mjs';
-import { installUserCopilotAssets } from './install-user-copilot-assets.mjs';
-import { createInterface } from 'node:readline/promises';
+import { installUserAssetsForHarnesses } from '../src/install-user-assets.mjs';
+import { DEFAULT_HARNESS_IDS, HARNESSES, HARNESS_ENV_VAR, NON_INTERACTIVE_HARNESS_IDS, envHarnessSelection, harnessRoot } from '../src/harnesses.mjs';
 import { ReadStream as TTYReadStream, WriteStream as TTYWriteStream } from 'node:tty';
 import { homedir } from 'node:os';
-import { colorText, formatStatus } from '../src/terminal-ui.mjs';
+import { checkboxPrompt, colorText, formatStatus } from '../src/terminal-ui.mjs';
 import { brandedEnvValue, withBrandedEnvironment } from '../src/branding.mjs';
 import { generatedServerName } from '../src/mcp-config.mjs';
 import { redactText } from '../src/redact.mjs';
@@ -67,47 +67,83 @@ async function runInstallSetup() {
   return withInstallTerminal(terminal => runSetup({ env: runtimeEnv, ...(terminal || {}) }));
 }
 
-async function runCopilotAssetInstall() {
-  const copilotRoot = join(process.env.HOME || homedir(), '.copilot');
-  const installAssets = async () => {
-    const assets = await installUserCopilotAssets({ root });
+function harnessSelectionLabels(ids) {
+  return HARNESSES.filter(harness => ids.includes(harness.id)).map(harness => harness.label).join(', ');
+}
+
+async function resolveHarnessOverride() {
+  try {
+    return envHarnessSelection(runtimeEnv);
+  } catch (error) {
+    await announce(`${error.message} Ignoring ${HARNESS_ENV_VAR}.`, 'warning');
+    return null;
+  }
+}
+
+async function installSelectedHarnessAssets(ids) {
+  const { results, failures } = await installUserAssetsForHarnesses(ids, { root });
+  for (const failure of failures) {
+    await announce(`${failure.label}: bundled agent and skill installation failed: ${failure.error.message}`, 'error');
+  }
+  for (const assets of results) {
     const installed = assets.installed + assets.updated;
-    await announce(`Installed ${installed} Copilot files in ${assets.root}; ${assets.unchanged} already current.`, 'success');
+    await announce(`${assets.label}: ${installed} file${installed === 1 ? '' : 's'} installed or updated in ${assets.root}; ${assets.unchanged} already current.`, 'success');
     if (assets.conflicts.length > 0) {
       const paths = assets.conflicts.map(path => join(assets.root, path)).join(', ');
-      await announce(`Existing Copilot customizations were preserved; review these paths: ${paths}`, 'warning');
+      await announce(`${assets.label}: existing customizations were preserved; review these paths: ${paths}`, 'warning');
     }
-  };
+  }
+  const total = results.reduce((sum, assets) => sum + assets.installed + assets.updated, 0);
+  if (results.length > 0) {
+    await announce(`Installed ${total} files across ${results.length} harness${results.length === 1 ? '' : 'es'}.`, 'success');
+  }
+}
+
+async function runHarnessAssetInstall() {
+  const home = process.env.HOME || homedir();
+  const override = await resolveHarnessOverride();
   await withInstallTerminal(async terminal => {
+    let selected = override;
     if (!terminal) {
-      await announce('Installing bundled agents and skills by default because no interactive terminal is available.', 'progress');
-      await installAssets();
+      if (!selected) selected = NON_INTERACTIVE_HARNESS_IDS;
+      await announce(`Installing bundled agents and skills for ${harnessSelectionLabels(selected)} by default because no interactive terminal is available.`, 'progress');
+      await installSelectedHarnessAssets(selected);
       return;
     }
+    if (!selected) selected = DEFAULT_HARNESS_IDS;
     await announce([
-      'Bundled Copilot agents and skills are installed by default.',
-      '',
-      'Type n then press Enter to skip installing or updating the bundled files.',
+      'The bundled agents and skills can be installed for several AI coding harnesses.',
       '',
-      `${colorText('✅ Press Enter', 'green', true)} to install or update the bundled agents and all skills.`,
-      `${colorText('⏭️  Type n then Enter', 'yellow', true)} to skip this step.`,
+      'Space = select or deselect · a = toggle all · Enter = confirm. Pressing Enter without changes installs the pre-checked harnesses; confirming with none selected skips this step.',
       '',
-      `${colorText('📁 Target folder:', 'cyan', true)}`,
-      `   ${copilotRoot}`,
+      `${colorText('📁 Target folders:', 'cyan', true)}`,
+      ...HARNESSES.map(harness => `   ${harnessRoot(harness, { home, env: runtimeEnv })} — ${harness.label} (${harness.supportsAgents ? 'skills + agents' : 'skills only'})`),
       ''
     ].join('\n'), 'copilot');
-    const prompt = createInterface({ input: terminal.input, output: terminal.output });
     let answer;
     try {
-      answer = await prompt.question(`${colorText('🤖 Install the bundled agents and all skills?', 'magenta', terminal.output)} ${colorText('[Y/n]', 'yellow', terminal.output)} `);
-    } finally {
-      prompt.close();
+      answer = await checkboxPrompt({
+        message: colorText('🤖 Install bundled agents and skills for', 'magenta', terminal.output),
+        choices: HARNESSES.map(harness => ({
+          value: harness.id,
+          name: `${harness.label} (${harness.supportsAgents ? 'skills + agents' : 'skills'})`,
+          checked: selected.includes(harness.id)
+        })),
+        required: false,
+        shortcuts: { all: 'a' }
+      }, { input: terminal.input, output: terminal.output });
+    } catch (error) {
+      if (error.message === 'Prompt interrupted') {
+        await announce('Bundled agents and skills were skipped because the prompt was interrupted. Your files were not changed.', 'info');
+        return;
+      }
+      throw error;
     }
-    if (/^n(?:o)?$/i.test(answer.trim())) {
-      await announce('Copilot agent and skills were skipped. Your files were not changed.', 'info');
+    if (answer.length === 0) {
+      await announce('Bundled agents and skills were skipped. Your files were not changed.', 'info');
       return;
     }
-    await installAssets();
+    await installSelectedHarnessAssets(answer);
   });
 }
 
@@ -256,9 +292,9 @@ async function main() {
   }
 
   try {
-    await runCopilotAssetInstall();
+    await runHarnessAssetInstall();
   } catch (error) {
-    await announce(`Copilot agent and skill installation failed: ${error.message}`, 'error');
+    await announce(`Bundled agent and skill installation failed: ${error.message}`, 'error');
   }
   if (setupCompleted) await announceSetup(setupResult);
 }

package/src/abaplint.mjs

@@ -2,7 +2,7 @@ import { Config, MemoryFile, Registry } from '@abaplint/core';
 
 export const ABAP_LINT_TOOL = {
   name: 'LintABAP',
-  description: 'Run abaplint on caller-supplied ABAPGit-serialized files in memory; does not read workspace files or call SAP.',
+  description: 'Run abaplint on caller-supplied source files in memory; does not read workspace files or call SAP.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -50,7 +50,7 @@ function validateArguments(arguments_) {
     }
     const basename = file.filename.split(/[\\/]/).at(-1);
     if (!/^[^.]+\.[^.]+\.[^.]+$/.test(basename)) {
-      throw new Error('Each filename must have an abapGit object.type.extension basename');
+      throw new Error('Each filename must have an object.type.extension basename');
     }
   }
   if (arguments_.config !== undefined && !isObject(arguments_.config)) {

package/src/harnesses.mjs

@@ -0,0 +1,93 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const HARNESS_ENV_VAR = 'SAP_AI_DEV_TOOLKIT_HARNESSES';
+export const DEFAULT_HARNESS_IDS = ['github-copilot', 'claude-code'];
+export const NON_INTERACTIVE_HARNESS_IDS = ['github-copilot'];
+
+const FRONTMATTER_PATTERN = /^---\n([\s\S]*?)\n---\n/;
+
+function splitFrontmatter(source) {
+  const match = FRONTMATTER_PATTERN.exec(String(source));
+  if (!match) return null;
+  const fields = match[1].split('\n').map(line => {
+    const separator = line.indexOf(':');
+    return { key: line.slice(0, separator).trim(), value: line.slice(separator + 1).trim() };
+  });
+  if (fields.some(field => !field.key)) return null;
+  return { fields, body: String(source).slice(match[0].length) };
+}
+
+function requiredField(fields, key) {
+  const field = fields.find(entry => entry.key === key);
+  return field && field.value ? field.value : null;
+}
+
+function renderDocument(fields, body) {
+  return `---\n${fields.map(field => `${field.key}: ${field.value}`).join('\n')}\n---\n${body}`;
+}
+
+export function agentMarkdownName(fileName) {
+  return String(fileName).replace(/\.agent\.md$/, '.md');
+}
+
+export function claudeCodeAgentDocument(source) {
+  const frontmatter = splitFrontmatter(source);
+  if (!frontmatter) throw new Error('unsupported agent frontmatter');
+  const kept = frontmatter.fields
+    .filter(field => field.key === 'name' || field.key === 'description')
+    .filter(field => field.value);
+  if (!requiredField(frontmatter.fields, 'name') || !requiredField(frontmatter.fields, 'description')) {
+    throw new Error('unsupported agent frontmatter');
+  }
+  return renderDocument(kept, frontmatter.body);
+}
+
+export function opencodeAgentDocument(source) {
+  const frontmatter = splitFrontmatter(source);
+  if (!frontmatter) throw new Error('unsupported agent frontmatter');
+  const description = requiredField(frontmatter.fields, 'description');
+  if (!description) throw new Error('unsupported agent frontmatter');
+  return renderDocument([{ key: 'description', value: description }, { key: 'mode', value: 'subagent' }], frontmatter.body);
+}
+
+export const HARNESSES = [
+  { id: 'github-copilot', label: 'GitHub Copilot', directory: '.copilot', supportsAgents: true, legacyManifest: true },
+  { id: 'claude-code', label: 'Claude Code', directory: '.claude', supportsAgents: true, agentFileName: agentMarkdownName, agentDocument: claudeCodeAgentDocument },
+  { id: 'codex', label: 'OpenAI Codex', directory: '.agents', supportsAgents: false },
+  { id: 'cursor', label: 'Cursor', directory: '.cursor', supportsAgents: false },
+  { id: 'gemini-cli', label: 'Gemini CLI', directory: '.gemini', supportsAgents: false },
+  { id: 'opencode', label: 'opencode', directory: 'opencode', configHome: true, supportsAgents: true, agentFileName: agentMarkdownName, agentDocument: opencodeAgentDocument }
+];
+
+export function harnessById(id) {
+  const harness = HARNESSES.find(entry => entry.id === id);
+  if (!harness) {
+    throw new Error(`Unknown harness id: ${id}. Valid harness ids: ${HARNESSES.map(entry => entry.id).join(', ')}.`);
+  }
+  return harness;
+}
+
+export function harnessRoot(harness, { home = process.env.HOME || homedir(), env = process.env } = {}) {
+  if (harness.configHome) {
+    const override = typeof env?.XDG_CONFIG_HOME === 'string' ? env.XDG_CONFIG_HOME.trim() : '';
+    return join(override || join(home, '.config'), harness.directory);
+  }
+  return join(home, harness.directory);
+}
+
+export function parseHarnessSelection(raw) {
+  const tokens = [...new Set(String(raw).split(',').map(token => token.trim().toLowerCase()).filter(Boolean))];
+  const known = new Set(HARNESSES.map(entry => entry.id));
+  const unknown = tokens.filter(token => !known.has(token));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown harness id${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}. Valid harness ids: ${[...known].join(', ')}.`);
+  }
+  return HARNESSES.filter(entry => tokens.includes(entry.id)).map(entry => entry.id);
+}
+
+export function envHarnessSelection(env = process.env) {
+  const raw = env?.[HARNESS_ENV_VAR];
+  if (typeof raw !== 'string' || !raw.trim()) return null;
+  return parseHarnessSelection(raw);
+}

package/src/install-user-assets.mjs

@@ -0,0 +1,149 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { HARNESSES, harnessById, harnessRoot } from './harnesses.mjs';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+export const MANIFEST_NAME = '.sap-ai-dev-toolkit-assets.json';
+const LEGACY_MANIFEST_NAME = '.bas-mcp-addon-assets.json';
+
+function digest(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+async function collectFiles(sourceRoot, targetPrefix, relativePath = '') {
+  const files = [];
+  const entries = await readdir(join(sourceRoot, relativePath), { withFileTypes: true });
+  entries.sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    const childPath = join(relativePath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(sourceRoot, targetPrefix, childPath));
+    } else if (entry.isFile()) {
+      files.push({ source: join(sourceRoot, childPath), target: join(targetPrefix, childPath) });
+    }
+  }
+  return files;
+}
+
+async function readManagedFiles(path) {
+  try {
+    const manifest = JSON.parse(await readFile(path, 'utf8'));
+    if (manifest === null || typeof manifest !== 'object' || manifest.version !== 1 || manifest.files === null || typeof manifest.files !== 'object' || Array.isArray(manifest.files)) return {};
+    return manifest.files;
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) return {};
+    throw error;
+  }
+}
+
+async function replaceFile(path, content) {
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, content, { flag: 'wx', mode: 0o644 });
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
+async function collectSourceFiles(root) {
+  const sourceRoot = join(root, '.github');
+  const files = [
+    ...await collectFiles(join(sourceRoot, 'agents'), 'agents'),
+    ...await collectFiles(join(sourceRoot, 'skills'), 'skills')
+  ];
+  if (!files.some(file => file.target === join('agents', 'abap-developer.agent.md'))) {
+    throw new Error('Packaged ABAP Developer agent profile is missing');
+  }
+  if (!files.some(file => file.target.startsWith(`skills${sep}`) && file.target.endsWith('SKILL.md'))) {
+    throw new Error('Packaged Agent Skills are missing');
+  }
+  return files;
+}
+
+async function planDestinations(harness, files) {
+  const destinations = [];
+  for (const file of files) {
+    const raw = await readFile(file.source);
+    if (!file.target.startsWith(`agents${sep}`)) {
+      destinations.push({ target: file.target, content: raw });
+      continue;
+    }
+    if (!harness.supportsAgents) continue;
+    const fileName = harness.agentFileName ? harness.agentFileName(basename(file.target)) : basename(file.target);
+    const content = harness.agentDocument ? Buffer.from(harness.agentDocument(raw.toString('utf8')), 'utf8') : raw;
+    destinations.push({ target: join('agents', fileName), content });
+  }
+  return destinations;
+}
+
+export async function installUserAssets({ harness, home = process.env.HOME || homedir(), root = packageRoot, env = process.env } = {}) {
+  const destinations = await planDestinations(harness, await collectSourceFiles(root));
+  const targetRoot = harnessRoot(harness, { home, env });
+  const manifestPath = join(targetRoot, MANIFEST_NAME);
+  const legacyManifestPath = join(targetRoot, LEGACY_MANIFEST_NAME);
+  await mkdir(targetRoot, { recursive: true, mode: 0o755 });
+  const legacyFiles = harness.legacyManifest ? await readManagedFiles(legacyManifestPath) : {};
+  const currentFiles = await readManagedFiles(manifestPath);
+  const previousFiles = { ...legacyFiles, ...currentFiles };
+  const managedFiles = { ...previousFiles };
+  const conflicts = [];
+  let installed = 0;
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const file of destinations) {
+    const destination = join(targetRoot, file.target);
+    const contentHash = digest(file.content);
+    await mkdir(dirname(destination), { recursive: true, mode: 0o755 });
+
+    let existing;
+    try {
+      existing = await readFile(destination);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      try {
+        await writeFile(destination, file.content, { flag: 'wx', mode: 0o644 });
+        managedFiles[file.target] = contentHash;
+        installed += 1;
+        continue;
+      } catch (writeError) {
+        if (writeError.code !== 'EEXIST') throw writeError;
+        existing = await readFile(destination);
+      }
+    }
+
+    const existingHash = digest(existing);
+    if (existingHash === contentHash) {
+      managedFiles[file.target] = contentHash;
+      unchanged += 1;
+    } else if (previousFiles[file.target] === existingHash) {
+      await replaceFile(destination, file.content);
+      managedFiles[file.target] = contentHash;
+      updated += 1;
+    } else {
+      conflicts.push(file.target);
+    }
+  }
+
+  await replaceFile(manifestPath, `${JSON.stringify({ version: 1, files: managedFiles }, null, 2)}\n`);
+  if (harness.legacyManifest) await rm(legacyManifestPath, { force: true });
+  return { harness: harness.id, label: harness.label, root: targetRoot, installed, updated, unchanged, conflicts };
+}
+
+export async function installUserAssetsForHarnesses(ids, { home, root = packageRoot, env = process.env } = {}) {
+  const results = [];
+  const failures = [];
+  for (const id of ids) {
+    try {
+      results.push(await installUserAssets({ harness: harnessById(id), home, root, env }));
+    } catch (error) {
+      const entry = HARNESSES.find(harness => harness.id === id);
+      failures.push({ id, label: entry ? entry.label : id, error });
+    }
+  }
+  return { results, failures };
+}

package/src/launcher.mjs

@@ -89,16 +89,6 @@ async function runDoctor(destinations) {
       const initialized = await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } });
       if (initialized?.error) throw new Error(initialized.error.message || 'MCP initialization failed');
       checks.push(doctorRow(destination.name, 'VSP MCP startup', 'passed', 'initialized'));
-      const relayedDestination = proxy.children[0]?.destination;
-      if (relayedDestination?.relay) {
-        checks.push(doctorRow(destination.name, 'BAS destination relay', 'passed', `enabled (${relayedDestination.url}); runtime session preflight pending`));
-      } else if (destination.source === 'cloud-foundry') {
-        checks.push(doctorRow(destination.name, 'BAS destination relay', 'skipped', 'Cloud Foundry destinations connect through the connectivity proxy directly.'));
-      } else if (String(runtimeEnv.SAP_AI_DEV_TOOLKIT_DISABLE_BAS_RELAY || '').toLowerCase() === 'true') {
-        checks.push(doctorRow(destination.name, 'BAS destination relay', 'skipped', 'Disabled through SAP_AI_DEV_TOOLKIT_DISABLE_BAS_RELAY.'));
-      } else {
-        checks.push(doctorRow(destination.name, 'BAS destination relay', 'skipped', 'Not applicable for this destination.'));
-      }
       const listed = await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
       if (listed?.error) throw new Error(listed.error.message || 'MCP tools/list failed');
       const tools = listed.result?.tools || [];
@@ -114,32 +104,9 @@ async function runDoctor(destinations) {
       if (!systemInfo) {
         checks.push(doctorRow(destination.name, 'SAP system check', 'skipped', 'GetSystemInfo is not exposed by this VSP mode.'));
       } else {
-        let sessionReady = true;
-        if (relayedDestination?.relay?.probeCsrfSession) {
-          let session;
-          let preflightError;
-          try {
-            session = await relayedDestination.relay.probeCsrfSession();
-          } catch (error) {
-            preflightError = redactText(error.message || error).slice(0, 250);
-          }
-          sessionReady = session?.sessionUsable === true;
-          const status = sessionReady ? 'passed' : 'failed';
-          const stats = relayedDestination.relay.stats || {};
-          const detail = preflightError
-            ? `preflight request failed: ${preflightError}`
-            : `HTTP ${session?.httpStatus || 0}; token=${session?.tokenReceived ? 'received' : 'missing'}; cookies=${session?.cookieCount || 0}; usableSession=${sessionReady}; csrfFetches=${stats.csrfFetches || 0}; csrfRetries=${stats.csrfRetries || 0}; sessionFailures=${stats.csrfSessionFailures || 0}; tunnelFallbacks=${stats.tunnelFallbacks || 0}`;
-          checks.push(doctorRow(destination.name, 'BAS relay CSRF preflight', status, detail));
-          if (!sessionReady) {
-            const remediation = 'GetSystemInfo was not called because the relay could not establish a paired CSRF token/session. Confirm the configured destination authentication and BAS proxy route.';
-            checks.push(doctorRow(destination.name, 'SAP system check', 'skipped', preflightError ? `${remediation} Relay error: ${preflightError}` : remediation));
-          }
-        }
-        if (sessionReady) {
-          const inspected = await proxy.handle({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: systemInfo.name, arguments: {} } });
-          const failed = inspected?.error || inspected?.result?.isError;
-          checks.push(doctorRow(destination.name, 'SAP system check', failed ? 'failed' : 'passed', failed ? redactText(inspected?.error?.message || inspected?.result?.content?.[0]?.text || 'GetSystemInfo failed') : 'GetSystemInfo returned successfully'));
-        }
+        const inspected = await proxy.handle({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: systemInfo.name, arguments: {} } });
+        const failed = inspected?.error || inspected?.result?.isError;
+        checks.push(doctorRow(destination.name, 'SAP system check', failed ? 'failed' : 'passed', failed ? redactText(inspected?.error?.message || inspected?.result?.content?.[0]?.text || 'GetSystemInfo failed') : 'GetSystemInfo returned successfully'));
       }
     } catch (error) {
       const detail = redactText(error.message || error).slice(0, 300);

package/src/mcp-proxy.mjs

@@ -4,7 +4,6 @@ import { sanitizeChildEnv, slugifyDestination } from './bas-discovery.mjs';
 import { ABAP_LINT_TOOL, runABAPLint } from './abaplint.mjs';
 import { createEngineeringTools } from './engineering-tools.mjs';
 import { brandedEnvValue } from './branding.mjs';
-import { createBasDestinationRelay } from './bas-destination-relay.mjs';
 import { diagnosticText, redactText } from './redact.mjs';
 
 const JSONRPC = '2.0';
@@ -167,12 +166,6 @@ function closeDestinationRoute(destination) {
   return closedRoutes.get(destination);
 }
 
-function useBasDestinationRelay(destination, env = process.env) {
-  if (String(brandedEnvValue(env, 'DISABLE_BAS_RELAY') || '').toLowerCase() === 'true') return false;
-  if (destination.source === 'cloud-foundry') return false;
-  if (!destination.authentication) return false;
-  return Boolean(destination.url && String(destination.url).includes('.dest'));
-}
 
 function useProxyAuthentication(destination) {
   return destination.source !== 'cloud-foundry' || destination.authentication === 'PrincipalPropagation';
@@ -190,17 +183,6 @@ function childEnvironment(destination, env) {
       'SAP_SAML_AUTH', 'SAP_SAML_USER', 'SAP_SAML_PASSWORD', 'SAP_CREDENTIAL_CMD'
     ]) childEnv[key] = '';
   }
-  // The VSP child must reach the local BAS relay directly, never through the
-  // BAS .dest proxy. Without a loopback exception every child request would
-  // be double-proxied and the relay's session pairing could never apply.
-  if (destination.relay) {
-    const loopback = '127.0.0.1,localhost';
-    for (const key of ['NO_PROXY', 'no_proxy']) {
-      const entries = String(childEnv[key] || '').split(',').map(value => value.trim()).filter(Boolean);
-      for (const host of loopback.split(',')) if (!entries.some(entry => entry.toLowerCase() === host)) entries.push(host);
-      childEnv[key] = entries.join(',');
-    }
-  }
   return childEnv;
 }
 
@@ -245,14 +227,12 @@ class Child {
     this.process.on('error', error => {
       if (!this.closing && !this.pending.size && this.options.log) this.options.log(`[${destination.name}] VSP child process error: ${diagnosticText(error.message)}`);
       this.fail(error);
-      // Relay routes survive child crashes so self-healing restarts can reuse
-      // them; they are closed by the proxy shutdown path instead.
-      if (!destination.relay) void closeDestinationRoute(destination);
+      void closeDestinationRoute(destination);
     });
     this.process.on('exit', (code, signal) => {
       if (!this.closing && !this.pending.size && this.options.log) this.options.log(`[${destination.name}] VSP child exited (${code ?? signal})`);
       this.fail(new Error(`child exited (${code ?? signal})`));
-      if (!destination.relay) void closeDestinationRoute(destination);
+      void closeDestinationRoute(destination);
     });
   }
 
@@ -442,34 +422,10 @@ export class MCPProxy {
     if (this.started) return this;
     this.started = true;
     this.starting = (async () => {
-      // Destinations start concurrently (relay bind + child spawn); children
-      // are assembled in destination order, which keeps serverInfo's
-      // children[0] fallback and merged slug numbering deterministic.
-      const started = await Promise.all(this.destinations.map(originalDestination => (async () => {
-        let destination = originalDestination;
-        let relay;
+      // Destinations start concurrently and are assembled in destination order,
+      // keeping serverInfo's children[0] fallback and merged slug numbering deterministic.
+      const started = await Promise.all(this.destinations.map(destination => (async () => {
         try {
-          if (useBasDestinationRelay(originalDestination, this.env)) {
-            relay = createBasDestinationRelay(originalDestination, { env: this.env, log: message => this.eventSink(message) });
-            const originalClose = originalDestination.close;
-            const relayUrl = await relay.ready;
-            destination = {
-              ...originalDestination,
-              url: relayUrl,
-              relay: {
-                probeCsrfSession: relay.probeCsrfSession,
-                stats: relay.stats
-              },
-              async close() {
-                try {
-                  await originalClose?.();
-                } finally {
-                  await relay.close();
-                }
-              }
-            };
-            this.eventSink(`[${originalDestination.name}] BAS destination relay enabled (${relayUrl})`);
-          }
           this.eventSink(`[${destination.name}] starting VSP child (client=${destination.client || '001'})`);
           return {
             destination,
@@ -477,8 +433,6 @@ export class MCPProxy {
           };
         } catch (error) {
           this.eventSink(`[${destination.name}] failed to start child: ${diagnosticText(error.message)}`, 'error');
-          // A relay whose ready promise rejected still owns dispatchers.
-          if (relay && destination === originalDestination) await relay.close().catch(() => {});
           void closeDestinationRoute(destination);
           return null;
         }

package/dist/checksums.txt

@@ -1,5 +0,0 @@
-78c0f6b7adf151a4c83ee3a757752aa409225fc75af64dfe728aed68dc5cf598  vsp-linux-x64
-4ceaf3ef3519431aa5ebe7d7c14569cf7c7035956dbfc9342c8fa9b6343a5380  vsp-linux-arm64
-f8d075f1ef955f8bb4be5b1d9ec3ffc86e84349b8a141265cf39e74c9fd83246  vsp-darwin-x64
-25e19e0d7317fe5adcb3c670b5fcf1da1caafa3c1bf8a6783c4ff00b312b5194  vsp-darwin-arm64
-c67c921ae884abeacaa39782c5524f58ec58bdbccc0d7097ee8a2499c04331ac  vsp-win32-x64.exe