deadbyte-mcp 0.15.34 → 0.15.36

package/bridge/src/bridge.mjs

@@ -0,0 +1,487 @@
+import { createHash } from 'node:crypto';
+import { createServer } from 'node:http';
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { McpServer, createMcpHandler, createRequestStateCodec, inputRequired, inputResponse } from '@modelcontextprotocol/server';
+import {preparePublicToolDefinitions} from './public-tool-definitions.mjs';
+import {createDeadbyteNodeHandler} from './node-http-adapter.mjs';
+import { bridgeCatalogSha256, bridgeDeadlineForTool, createBridgeGovernor, enforceDesktopBridgeResult, verifyCompactCatalogAttestation } from './r40-governor.mjs';
+import { createBridgeHealth } from './bridge-health-r59.mjs';
+
+const coreRoot = path.resolve(process.env.DEADBYTE_CORE_ROOT ?? 'C:/Users/DEADBYTE/Downloads/deadbyte-mcp-v0.6.0');
+const coreServer = path.join(coreRoot, 'src', 'mcp-server.mjs');
+const workspaceRoot = path.resolve(process.env.DEADBYTE_WORKSPACE_ROOT ?? path.join(coreRoot, 'workspaces'));
+const port = Number(process.env.DEADBYTE_BRIDGE_PORT ?? '8787');
+const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open'];
+const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
+const agentTools = [
+  'agent_task_approve', 'agent_task_cancel', 'agent_task_events', 'agent_task_run',
+  'agent_task_status', 'agent_task_submit', 'agent_task_verify'
+];
+const codingTools = [
+  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write',
+  'coding_receipt_verify', 'coding_session_status', 'coding_task_approve', 'coding_task_cancel',
+  'coding_task_events', 'coding_task_run', 'coding_task_status', 'coding_task_submit',
+  'coding_task_verify', 'coding_text_replace', 'coding_tree'
+];
+const autonomousTools = [
+  'autonomous_goal_approve', 'autonomous_goal_cancel', 'autonomous_goal_events',
+  'autonomous_goal_run', 'autonomous_goal_status', 'autonomous_goal_submit',
+  'autonomous_goal_verify', 'autonomous_release_gate', 'autonomous_session_status',
+  'native_diff_apply', 'native_diff_preview', 'native_diff_verify'
+];
+const r35FullTools = [
+  'agent_task_approve','agent_task_cancel','agent_task_events','agent_task_run','agent_task_status','agent_task_submit','agent_task_verify',
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_events','autonomous_goal_run','autonomous_goal_status','autonomous_goal_submit','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status',
+  'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_files_read','coding_receipt_verify','coding_search','coding_session_status','coding_stat',
+  'coding_symbol_definition','coding_symbol_outline','coding_symbol_references','coding_symbol_replace',
+  'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree',
+  'contained_transform','evidence_verify','file_read',
+  'host_exec','host_file_read','host_file_write',
+  'machine_fs_delete','machine_fs_edit_exact','machine_fs_list','machine_fs_mkdir','machine_fs_move','machine_fs_read','machine_fs_stat','machine_fs_write',
+  'machine_list','machine_ping','machine_process_list','machine_revoke','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_status','machine_system_status',
+  'native_diff_apply','native_diff_preview','native_diff_verify',
+  'process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate',
+  'proof_execute','workspace_open'
+].sort();
+const r36CompactTools = [
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_events','autonomous_goal_run','autonomous_goal_status','autonomous_goal_submit','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status',
+  'capability_manifest',
+  'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_inspect','coding_receipt_verify','coding_session_status','coding_symbol_replace',
+  'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree',
+  'evidence_verify',
+  'host_exec','host_file_read','host_file_write',
+  'machine_fs','machine_list','machine_observe','machine_ping','machine_revoke','machine_status',
+  'native_diff_apply','native_diff_preview','native_diff_verify',
+  'process_session'
+].sort();
+if (r35FullTools.length !== 73) throw new Error(`R35 production catalog constant drift: ${r35FullTools.length}`);
+if (r36CompactTools.length !== 41) throw new Error(`R36 compact catalog constant drift: ${r36CompactTools.length}`);
+const AUTONOMOUS_DOWNSTREAM_TIMEOUT_MS = 900000;
+const AUTONOMOUS_DOWNSTREAM_TOTAL_MS = 1200000;
+const AUDIT_MAX_STRING_BYTES = 512;
+const AUDIT_MAX_ARRAY_ITEMS = 24;
+const AUDIT_MAX_OBJECT_KEYS = 48;
+const SENSITIVE_AUDIT_KEY = /(token|secret|password|authorization|cookie|recovery|private[_-]?key)/i;
+const PAYLOAD_AUDIT_KEY = /^(content|raw_text|text)$/i;
+let auditSequence = 0;
+const bridgeGovernor = createBridgeGovernor();
+const bridgeHealth=createBridgeHealth({maxCapabilityAgeMs:15000});
+
+function auditDigest(text) {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+function auditString(value, key = '') {
+  const bytes = Buffer.byteLength(value, 'utf8');
+  if (SENSITIVE_AUDIT_KEY.test(key)) return `<redacted bytes=${bytes} sha256=${auditDigest(value)}>`;
+  if (PAYLOAD_AUDIT_KEY.test(key)) return `<payload bytes=${bytes} sha256=${auditDigest(value)}>`;
+  if (/^(?:Bearer\s+|Basic\s+|sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{12,})/i.test(value)) {
+    return `<redacted bytes=${bytes} sha256=${auditDigest(value)}>`;
+  }
+  if (bytes <= AUDIT_MAX_STRING_BYTES) return value;
+  const prefix = value.slice(0, 256);
+  return `${prefix}<truncated bytes=${bytes} sha256=${auditDigest(value)}>`;
+}
+
+function auditSanitize(value, key = '', depth = 0) {
+  if (value === null || value === undefined) return value ?? null;
+  if (depth > 6) return '<depth-limit>';
+  if (typeof value === 'string') return auditString(value, key);
+  if (typeof value === 'number' || typeof value === 'boolean') return value;
+  if (typeof value === 'bigint') return value.toString();
+  if (Array.isArray(value)) {
+    const out = value.slice(0, AUDIT_MAX_ARRAY_ITEMS).map(item => auditSanitize(item, key, depth + 1));
+    if (value.length > AUDIT_MAX_ARRAY_ITEMS) out.push(`<${value.length - AUDIT_MAX_ARRAY_ITEMS} more items>`);
+    return out;
+  }
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).slice(0, AUDIT_MAX_OBJECT_KEYS);
+    const out = {};
+    for (const [childKey, childValue] of entries) out[childKey] = auditSanitize(childValue, childKey, depth + 1);
+    if (Object.keys(value).length > AUDIT_MAX_OBJECT_KEYS) out._truncated_keys = Object.keys(value).length - AUDIT_MAX_OBJECT_KEYS;
+    return out;
+  }
+  return String(value);
+}
+
+const BRIDGE_LOG_LEVEL = process.env.DEADBYTE_BRIDGE_LOG_LEVEL === 'debug' ? 'debug' : 'human';
+
+function auditWrite(kind, call, payload) {
+  const stamp = new Date().toISOString();
+  const id = String(call.id).padStart(6, '0');
+  console.log(`[TOOL ${kind}] ${stamp} #${id} ${call.name} ${JSON.stringify(auditSanitize(payload))}`);
+}
+
+function compactDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '0ms';
+  if (ms < 10) return `${ms.toFixed(1)}ms`;
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`;
+}
+
+function auditShortReason(result, error = null) {
+  const structured = result?.structuredContent;
+  const candidates = error
+    ? [error?.message ?? String(error)]
+    : [
+        structured?.error, structured?.message, structured?.reason,
+        structured?.result?.error, structured?.result?.message,
+        ...(Array.isArray(result?.content) ? result.content.filter(item => item?.type === 'text').map(item => item.text) : [])
+      ];
+  for (const candidate of candidates) {
+    if (typeof candidate !== 'string' || !candidate) continue;
+    const sanitized = auditString(candidate);
+    const text = String(sanitized).replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+    if (text) return text.length <= 180 ? text : `${text.slice(0, 179)}…`;
+  }
+  return '';
+}
+
+function auditCompactResult(call, { result = null, error = null } = {}) {
+  const elapsedMs = Number(process.hrtime.bigint() - call.started) / 1e6;
+  const failed = error !== null || result?.isError === true;
+  const reason = failed ? auditShortReason(result, error) : '';
+  const stamp = new Date().toISOString();
+  const id = String(call.id).padStart(6, '0');
+  console.log(`[TOOL] ${stamp} #${id} ${failed ? '✗' : '✓'} ${call.name} ${compactDuration(elapsedMs)}${reason ? ` — ${reason}` : ''}`);
+  return elapsedMs;
+}
+
+function auditToolStart(name, args) {
+  const call = { id: ++auditSequence, name, started: process.hrtime.bigint() };
+  if (BRIDGE_LOG_LEVEL === 'debug') auditWrite('IN ', call, args);
+  return call;
+}
+
+function auditToolFinish(call, result) {
+  const elapsedMs = auditCompactResult(call, { result });
+  if (BRIDGE_LOG_LEVEL === 'debug') {
+    auditWrite('OUT', call, {
+      elapsed_ms: Number(elapsedMs.toFixed(3)),
+      is_error: result?.isError === true,
+      structured: result?.structuredContent ?? null,
+      content: result?.content ?? null
+    });
+  }
+}
+
+function auditToolFail(call, error) {
+  const elapsedMs = auditCompactResult(call, { error });
+  if (BRIDGE_LOG_LEVEL === 'debug') {
+    auditWrite('ERR', call, {
+      elapsed_ms: Number(elapsedMs.toFixed(3)),
+      name: error?.name ?? 'Error',
+      message: error?.message ?? String(error)
+    });
+  }
+}
+
+const allowedCatalogs = [];
+for (const host of [false, true]) {
+  for (const agent of [false, true]) {
+    for (const coding of [false, true]) {
+      for (const autonomous of [false, true]) {
+        if (autonomous && !coding) continue;
+        const items = [...baseTools];
+        if (host) items.push(...privilegedTools);
+        if (agent) items.push(...agentTools);
+        if (coding) items.push(...codingTools);
+        if (autonomous) items.push(...autonomousTools);
+        allowedCatalogs.push(items.sort());
+      }
+    }
+  }
+}
+
+function loadToken() {
+  const fromEnv = process.env.DEADBYTE_BRIDGE_PATH_TOKEN ?? '';
+  if (/^[a-f0-9]{64}$/.test(fromEnv)) return fromEnv;
+  const tokenFile = process.env.DEADBYTE_BRIDGE_TOKEN_FILE ?? path.join(os.homedir(), '.deadbyte-mcp', 'bridge', 'path-token.txt');
+  const value = readFileSync(tokenFile, 'utf8').trim();
+  if (!/^[a-f0-9]{64}$/.test(value)) throw new Error(`invalid bridge path token file: ${tokenFile}`);
+  return value;
+}
+
+const token = loadToken();
+const requestStateKey = createHash('sha256')
+  .update('DEADBYTE-R24-MRTR-V1\0', 'utf8')
+  .update(token, 'utf8')
+  .digest();
+const requestStateCodec = createRequestStateCodec({ key: requestStateKey, ttlSeconds: 600 });
+if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('invalid DEADBYTE_BRIDGE_PORT');
+const endpointPath = `/mcp/${token}`;
+
+process.on('uncaughtExceptionMonitor', error => {
+  console.error(`[bridge-fatal-monitor] ${error?.stack ?? String(error)}`);
+});
+process.on('exit', code => {
+  console.error(`[bridge-exit] code=${code}`);
+});
+
+function newDownstreamClient(){return new Client(
+  {name:'deadbyte-chatgpt-bridge',version:'0.2.0'},
+  {versionNegotiation:{mode:{pin:'2026-07-28'}}}
+);}
+function newDownstreamTransport(){return new StdioClientTransport({command:process.execPath,args:[coreServer],cwd:coreRoot,
+  env:{...getDefaultEnvironment(),...process.env,DEADBYTE_WORKSPACE_ROOT:workspaceRoot},stderr:'pipe'});}
+function pipeCoreStderr(transport){transport.stderr?.on('data',chunk=>process.stderr.write(`[deadbyte-core] ${chunk}`));}
+
+let downstream=newDownstreamClient();
+let downstreamTransport=newDownstreamTransport();
+
+pipeCoreStderr(downstreamTransport);
+await downstream.connect(downstreamTransport);
+if (downstream.getProtocolEra() !== 'modern') throw new Error('DEADBYTE downstream is not modern MCP');
+
+const listed = await downstream.listTools();
+const actualNames = listed.tools.map(tool => tool.name).sort();
+const exactR36Compact = JSON.stringify(actualNames) === JSON.stringify(r36CompactTools);
+let compactCatalogAttestation = null;
+let compactCatalogLegacy = false;
+let currentCapabilityManifest = null;
+if (actualNames.includes('capability_manifest')) {
+  const manifestResult = await downstream.callTool(
+    { name:'capability_manifest', arguments:{} },
+    bridgeDeadlineForTool('capability_manifest')
+  );
+  const manifestSchema = manifestResult?.structuredContent?.result?.schema ?? null;
+  if (manifestSchema === 'deadbyte.capability-manifest.v2' || manifestSchema === 'deadbyte.capability-manifest.v3') {
+    compactCatalogAttestation = verifyCompactCatalogAttestation(actualNames, manifestResult);
+    if(manifestSchema==='deadbyte.capability-manifest.v3') currentCapabilityManifest=manifestResult.structuredContent.result;
+  } else if (manifestSchema === 'deadbyte.capability-manifest.v1' && exactR36Compact) {
+    compactCatalogLegacy = true;
+  } else {
+    throw new Error(`DEADBYTE compact catalog attestation unavailable or invalid schema: ${String(manifestSchema)}`);
+  }
+}
+const catalogOk = compactCatalogAttestation?.ok === true || compactCatalogLegacy ||
+  allowedCatalogs.some(expected => JSON.stringify(actualNames) === JSON.stringify(expected)) ||
+  JSON.stringify(actualNames) === JSON.stringify(r35FullTools);
+if (!catalogOk) throw new Error(`DEADBYTE tool catalog mismatch: ${JSON.stringify(actualNames)}`);
+const hostConfigured = privilegedTools.every(name => actualNames.includes(name));
+const agentConfigured = agentTools.every(name => actualNames.includes(name));
+const codingConfigured = codingTools.every(name => actualNames.includes(name));
+const autonomousConfigured = autonomousTools.every(name => actualNames.includes(name));
+const bridgeCatalogDigest = bridgeCatalogSha256(actualNames);
+const coreIdentity=createHash('sha256').update(readFileSync(coreServer)).digest('hex');
+bridgeHealth.coreConnected({childIdentity:coreIdentity,protocolEra:downstream.getProtocolEra(),catalogSha256:bridgeCatalogDigest});
+if(currentCapabilityManifest) bridgeHealth.capabilityObserved(currentCapabilityManifest);
+else bridgeHealth.degraded('capability manifest v3 is required for fresh readiness');
+
+async function refreshCapabilityAttestation(){
+  if(reconnecting||!bridgeHealth.snapshot().core)return;
+  try{
+    const result=await downstream.callTool({name:'capability_manifest',arguments:{}},bridgeDeadlineForTool('capability_manifest'));
+    verifyCompactCatalogAttestation(actualNames,result);
+    bridgeHealth.capabilityObserved(result.structuredContent.result);
+  }catch(error){bridgeHealth.degraded(`capability refresh failed: ${error?.message??String(error)}`);}
+}
+const capabilityRefreshTimer=setInterval(()=>{void refreshCapabilityAttestation();},4000);
+capabilityRefreshTimer.unref?.();
+let shuttingDown=false;
+let reconnecting=false;
+let downstreamGeneration=1;
+const reconnectDelays=[250,500,1000,2000,4000];
+const wait=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+async function attestReplacement(client){
+  if(client.getProtocolEra()!=='modern') throw new Error('replacement core protocol is not modern');
+  const replacement=(await client.listTools()).tools.map(tool=>tool.name).sort();
+  if(JSON.stringify(replacement)!==JSON.stringify(actualNames)) throw new Error('replacement core catalog drift');
+  const result=await client.callTool({name:'capability_manifest',arguments:{}},bridgeDeadlineForTool('capability_manifest'));
+  verifyCompactCatalogAttestation(actualNames,result);
+  if(result?.structuredContent?.result?.schema!=='deadbyte.capability-manifest.v3') throw new Error('replacement core capability manifest v3 missing');
+  return result.structuredContent.result;
+}
+function bindDownstreamClose(transport){
+  const sdkClose=transport.onclose;
+  transport.onclose=()=>{
+    sdkClose?.();
+    if(shuttingDown)return;
+    bridgeHealth.reconciling(`downstream core generation ${downstreamGeneration} closed`);
+    bridgeGovernor.reconcile('downstream core unavailable before dispatch');
+    void reconcileDownstream();
+  };
+}
+async function reconcileDownstream(){
+  if(reconnecting||shuttingDown)return;
+  reconnecting=true;
+  try{
+    for(let attempt=0;attempt<reconnectDelays.length&&!shuttingDown;attempt++){
+      await wait(reconnectDelays[attempt]);
+      const nextClient=newDownstreamClient(),nextTransport=newDownstreamTransport();
+      pipeCoreStderr(nextTransport);
+      try{
+        if(createHash('sha256').update(readFileSync(coreServer)).digest('hex')!==coreIdentity) throw new Error('core script identity drift');
+        await nextClient.connect(nextTransport);
+        const manifest=await attestReplacement(nextClient);
+        downstream=nextClient;downstreamTransport=nextTransport;downstreamGeneration++;
+        bindDownstreamClose(nextTransport);
+        bridgeHealth.coreConnected({childIdentity:coreIdentity,protocolEra:nextClient.getProtocolEra(),catalogSha256:bridgeCatalogDigest});
+        bridgeHealth.capabilityObserved(manifest);
+        return;
+      }catch(error){
+        await nextClient.close().catch(()=>{});
+        bridgeHealth.reconciling(`core reconnect ${attempt+1}/${reconnectDelays.length} failed: ${error?.message??String(error)}`);
+      }
+    }
+    bridgeHealth.degraded('core restart budget exhausted; bridge quarantined');
+  }finally{reconnecting=false;}
+}
+bindDownstreamClose(downstreamTransport);
+
+function plannerTextFromInput(ctx) {
+  const response = inputResponse(ctx.mcpReq.inputResponses, 'planner');
+  if (!response || response.kind !== 'sampling') throw new Error('planner sampling response missing');
+  const content = response.result?.content;
+  const block = Array.isArray(content) ? content.find(item => item?.type === 'text') : content;
+  if (!block || block.type !== 'text' || typeof block.text !== 'string') throw new Error('planner sampling response missing text');
+  return { raw_text: block.text, model: typeof response.result?.model === 'string' ? response.result.model.slice(0, 128) : 'client-model' };
+}
+
+const publicToolDefinitions=preparePublicToolDefinitions(listed.tools);
+
+function buildFrontServer() {
+  const front = new McpServer(
+    { name: 'deadbyte-chatgpt-bridge', version: '0.2.0' },
+    { requestState: { verify: requestStateCodec.verify } }
+  );
+  for (const tool of publicToolDefinitions) {
+    const {inputSchema,outputSchema}=tool;
+    front.registerTool(tool.name, {
+      title: tool.title,
+      description: tool.description,
+      inputSchema,
+      outputSchema,
+      annotations: tool.annotations
+    }, async (args, ctx) => {
+      const currentHealth=bridgeHealth.snapshot();
+      if(!currentHealth.core||['STARTING','RECONCILING','STOPPING'].includes(currentHealth.state)) throw new Error(`bridge correlation generation=${downstreamGeneration}; downstream ${currentHealth.state.toLowerCase()}; request not dispatched`);
+      if (tool.name !== 'autonomous_goal_run') {
+        const audit = auditToolStart(tool.name, args);
+        const ticket = await bridgeGovernor.acquire(tool.name,{signal:ctx.mcpReq.signal});
+        try {
+          const budget = bridgeDeadlineForTool(tool.name);
+          const result = await downstream.callTool({ name: tool.name, arguments: args }, budget);
+          enforceDesktopBridgeResult(tool.name, result);
+          auditToolFinish(audit, result);
+          return result;
+        } catch (error) {
+          auditToolFail(audit, error);
+          if(tool.annotations?.readOnlyHint!==true&&['RECONCILING','DEGRADED'].includes(bridgeHealth.snapshot().state)) throw new Error(`bridge correlation call=${audit.id} generation=${downstreamGeneration}; mutation outcome unknown; reconcile before retry`,{cause:error});
+          throw error;
+        } finally {
+          ticket.release();
+        }
+      }
+      const state = ctx.mcpReq.requestState();
+      const callArgs = { ...args };
+      if (state) {
+        if (state.goal_id !== args.goal_id || typeof state.request_id !== 'string') throw new Error('autonomous planner requestState binding mismatch');
+        const planner = plannerTextFromInput(ctx);
+        callArgs.planner_response = { request_id: state.request_id, raw_text: planner.raw_text, model: planner.model };
+      }
+      const audit = auditToolStart(tool.name, callArgs);
+      const ticket = await bridgeGovernor.acquire(tool.name,{signal:ctx.mcpReq.signal});
+      let result;
+      try {
+        const budget = bridgeDeadlineForTool(tool.name);
+        result = await downstream.callTool({ name: tool.name, arguments: callArgs }, budget);
+        auditToolFinish(audit, result);
+      } catch (error) {
+        auditToolFail(audit, error);
+        if(['RECONCILING','DEGRADED'].includes(bridgeHealth.snapshot().state)) throw new Error(`bridge correlation call=${audit.id} generation=${downstreamGeneration}; autonomous outcome unknown; reconcile before retry`,{cause:error});
+        throw error;
+      } finally {
+        ticket.release();
+      }
+      const plannerRequest = result?.structuredContent?.status === 'input_required' ? result.structuredContent.planner_request : null;
+      if (!plannerRequest) return result;
+      if (plannerRequest.request_id === undefined || typeof plannerRequest.prompt !== 'string') throw new Error('autonomous planner request malformed');
+      return inputRequired({
+        inputRequests: {
+          planner: inputRequired.createMessage({
+            messages: [{ role: 'user', content: { type: 'text', text: plannerRequest.prompt } }],
+            maxTokens: 4096,
+            temperature: 0,
+            includeContext: 'none'
+          })
+        },
+        requestState: await requestStateCodec.mint({ goal_id: args.goal_id, request_id: plannerRequest.request_id })
+      });
+    });
+  }
+  return front;
+}
+
+const mcpHandler = createMcpHandler(() => buildFrontServer(), {
+  legacy: 'reject',
+  responseMode: 'json',
+  onerror: error => console.error(`[mcp-http] ${error.stack ?? String(error)}`)
+});
+const nodeMcpHandler = createDeadbyteNodeHandler(mcpHandler);
+const httpServer = createServer(async (req, res) => {
+  try {
+    const pathname = new URL(req.url ?? '/', 'http://127.0.0.1').pathname;
+    if (pathname === '/healthz') {
+      const health=bridgeHealth.snapshot();
+      res.writeHead(health.http_status, { 'content-type': 'application/json; charset=utf-8','cache-control':'no-store' });
+      return res.end(JSON.stringify(health));
+    }
+    if (pathname === '/healthz/r40') {
+      const health=bridgeHealth.snapshot();
+      res.writeHead(health.http_status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+      return res.end(JSON.stringify({
+        status:health.ready?'ok':'degraded',runtime:health,catalog_sha256:bridgeCatalogDigest,
+        catalog_attestation:compactCatalogAttestation?.ok===true?'verified':compactCatalogLegacy?'legacy-r39':'not-applicable',
+        ledger_sha256:compactCatalogAttestation?.ledger_sha256??null,
+        governor:bridgeGovernor.snapshot()
+      }));
+    }
+    if (pathname !== endpointPath) {
+      res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+      return res.end('not found');
+    }
+    const contentLength = Number(req.headers['content-length'] ?? '0');
+    if (Number.isFinite(contentLength) && contentLength > 1024 * 1024) {
+      res.writeHead(413, { 'content-type': 'text/plain; charset=utf-8' });
+      return res.end('request too large');
+    }
+    await nodeMcpHandler(req, res);
+  } catch (error) {
+    if (!res.headersSent) res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
+    if (!res.writableEnded) res.end('bridge error');
+    console.error(error instanceof Error ? error.stack : String(error));
+  }
+});
+
+await new Promise((resolve, reject) => {
+  httpServer.once('error', reject);
+  httpServer.listen(port, '127.0.0.1', resolve);
+});
+console.log(`BRIDGE_READY http://127.0.0.1:${port}${endpointPath}`);
+console.log(`BRIDGE_TOOLS ${actualNames.join(',')}`);
+console.log(`BRIDGE_CATALOG_SHA256 ${bridgeCatalogDigest}`);
+console.log(`BRIDGE_CATALOG_ATTESTATION ${compactCatalogAttestation?.ok===true?'VERIFIED':compactCatalogLegacy?'LEGACY_R39':'NOT_APPLICABLE'}`);
+console.log(`BRIDGE_HOST_PLANE ${hostConfigured ? 'CONFIGURED_DISARMED_OR_ARMED_BY_LOCAL_LEASE' : 'UNCONFIGURED'}`);
+console.log(`BRIDGE_AGENT_RUNTIME ${agentConfigured ? 'ENABLED' : 'DISABLED'}`);
+console.log(`BRIDGE_CODING_RUNTIME ${codingConfigured ? 'ENABLED' : 'DISABLED'}`);
+console.log(`BRIDGE_AUTONOMOUS_RUNTIME ${autonomousConfigured ? 'ENABLED' : 'DISABLED'}`);
+
+async function shutdown() {
+  shuttingDown=true;
+  bridgeHealth.stopping();
+  clearInterval(capabilityRefreshTimer);
+  httpServer.close();
+  await Promise.race([bridgeGovernor.close('bridge stopping'),new Promise(resolve=>setTimeout(resolve,5000))]);
+  await mcpHandler.close().catch(() => {});
+  await downstream.close().catch(() => {});
+  process.exit(0);
+}
+process.once('SIGINT', shutdown);
+process.once('SIGTERM', shutdown);
+

package/bridge/src/node-http-adapter.mjs

@@ -0,0 +1,56 @@
+import {once} from 'node:events';
+
+function requestHeaders(headers){
+  const out=new Headers();
+  for(const [name,value] of Object.entries(headers??{})){
+    if(value===undefined) continue;
+    if(Array.isArray(value)){for(const item of value) out.append(name,String(item));}
+    else out.append(name,String(value));
+  }
+  return out;
+}
+async function requestBody(req,maxBodyBytes){
+  const method=String(req.method??'GET').toUpperCase();
+  if(method==='GET'||method==='HEAD') return undefined;
+  const chunks=[];let total=0;
+  for await(const chunk of req){
+    const bytes=Buffer.isBuffer(chunk)?chunk:Buffer.from(chunk);
+    total+=bytes.length;
+    if(total>maxBodyBytes) throw new Error(`bridge request body exceeds ${maxBodyBytes} bytes`);
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks,total);
+}
+async function writeResponse(res,response){
+  const headers={};
+  for(const [name,value] of response.headers.entries()) headers[name]=value;
+  res.writeHead(response.status,headers);
+  if(!response.body){res.end();return;}
+  const reader=response.body.getReader();
+  try{
+    while(true){
+      const {done,value}=await reader.read();
+      if(done) break;
+      if(res.destroyed){await reader.cancel().catch(()=>{});return;}
+      if(!res.write(value)) await once(res,'drain');
+    }
+  }finally{reader.releaseLock();}
+  if(!res.destroyed) res.end();
+}
+
+export function createDeadbyteNodeHandler(handler,{maxBodyBytes=1024*1024}={}){
+  if(!handler||typeof handler.fetch!=='function') throw new Error('bridge node adapter requires fetch-shaped MCP handler');
+  if(!Number.isInteger(maxBodyBytes)||maxBodyBytes<1024||maxBodyBytes>4*1024*1024) throw new Error('bridge node adapter maxBodyBytes invalid');
+  return async function nodeHandler(req,res){
+    const method=String(req.method??'GET').toUpperCase();
+    const url=new URL(String(req.url??'/'),'http://127.0.0.1');
+    const body=await requestBody(req,maxBodyBytes);
+    const init={method,headers:requestHeaders(req.headers)};
+    if(body!==undefined) init.body=body;
+    const request=new Request(url,init);
+    const options=req.auth?{authInfo:req.auth}:undefined;
+    const response=await handler.fetch(request,options);
+    if(!(response instanceof Response)) throw new Error('bridge MCP handler returned non-Response');
+    await writeResponse(res,response);
+  };
+}

package/bridge/src/public-tool-definitions.mjs

@@ -0,0 +1,14 @@
+import {fromJsonSchema} from '@modelcontextprotocol/server';
+
+// Catalog is fixed by the existing downstream startup attestation. Only schema
+// definitions/validators are shared; servers, callbacks and requestState aren't.
+export function preparePublicToolDefinitions(tools){
+ return Object.freeze(tools.map(tool=>{
+  const input=structuredClone(tool.inputSchema??{type:'object',properties:{},additionalProperties:false});
+  if(tool.name==='autonomous_goal_run'){
+   if(input.properties&&typeof input.properties==='object')delete input.properties.planner_response;
+   if(Array.isArray(input.required))input.required=input.required.filter(name=>name!=='planner_response');
+  }
+  return Object.freeze({...tool,inputSchema:fromJsonSchema(input),outputSchema:tool.outputSchema?fromJsonSchema(tool.outputSchema):undefined});
+ }));
+}