deadbyte-mcp 0.8.7

package/src/remote-mcp-smoke-client.mjs

@@ -0,0 +1,162 @@
+import { randomBytes } from 'node:crypto';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+
+const endpointText = process.argv[2];
+const mode = process.argv[3] ?? 'smoke';
+if (!endpointText) throw new Error('usage: node src/remote-mcp-smoke-client.mjs https://host/mcp/path [smoke|full]');
+if (!['smoke', 'full'].includes(mode)) throw new Error('mode must be smoke or full');
+const endpoint = new URL(endpointText);
+if (endpoint.protocol !== 'https:') throw new Error('remote MCP gate requires HTTPS');
+
+const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open'];
+const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
+const machineTools = ['machine_list', 'machine_ping', 'machine_revoke', 'machine_status'];
+const processTools = [
+  'process_session_action', 'process_session_list', 'process_session_read', 'process_session_start',
+  'process_session_status', 'process_session_terminate'
+];
+const machineFsTools = [
+  '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'
+];
+const observationTools = [
+  'machine_search_start', 'machine_search_page', 'machine_search_status',
+  'machine_search_cancel', 'machine_process_list', 'machine_system_status'
+];
+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_search', 'coding_session_status', 'coding_stat',
+  '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 allowedCatalogs = [];
+for (const machine of [false, true]) for (const host of [false, true]) for (const agent of [false, true]) {
+  for (const processPlane of [false, true]) for (const machineFs of [false, true]) for (const observation of [false, true]) for (const codingMode of ['none', 'coding', 'autonomous']) {
+    if (machineFs && codingMode === 'none') continue;
+    if (observation && (!machine || codingMode === 'none')) continue;
+    const items = [...baseTools];
+    if (machine) items.push(...machineTools);
+    if (host) items.push(...privilegedTools);
+    if (agent) items.push(...agentTools);
+    if (processPlane) items.push(...processTools);
+    if (machineFs) items.push(...machineFsTools);
+    if (observation) items.push(...observationTools);
+    if (codingMode !== 'none') items.push(...codingTools);
+    if (codingMode === 'autonomous') items.push(...autonomousTools);
+    allowedCatalogs.push(items.sort());
+  }
+}
+
+const client = new Client(
+  { name: 'deadbyte-mcp-remote-gate', version: '0.8.0' },
+  { versionNegotiation: { mode: { pin: '2026-07-28' } } }
+);
+const transport = new StreamableHTTPClientTransport(endpoint);
+
+function structured(result, label) {
+  if (result.isError) throw new Error(`${label} returned tool error: ${JSON.stringify(result.structuredContent ?? result.content)}`);
+  if (!result.structuredContent || typeof result.structuredContent !== 'object') throw new Error(`${label} returned no structured object`);
+  return result.structuredContent;
+}
+
+try {
+  await client.connect(transport);
+  if (client.getProtocolEra() !== 'modern') throw new Error(`expected modern MCP era, got ${String(client.getProtocolEra())}`);
+  const listed = await client.listTools();
+  const names = listed.tools.map(t => t.name).sort();
+  const catalogOk = allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected));
+  if (!catalogOk) throw new Error(`tool catalog mismatch: ${JSON.stringify(names)}`);
+  for (const tool of listed.tools) {
+    if (tool.outputSchema?.type !== 'object' || tool.outputSchema?.additionalProperties !== false || !tool.outputSchema?.properties) {
+      throw new Error(`tool ${tool.name} missing strict output schema`);
+    }
+  }
+  const machineRuntime = machineTools.every(name => names.includes(name));
+  const privilegedHostPlane = privilegedTools.every(name => names.includes(name));
+  const agentRuntime = agentTools.every(name => names.includes(name));
+  const processRuntime = processTools.every(name => names.includes(name));
+  const machineFsRuntime = machineFsTools.every(name => names.includes(name));
+  const observationRuntime = observationTools.every(name => names.includes(name));
+  const codingRuntime = codingTools.every(name => names.includes(name));
+  const autonomousRuntime = autonomousTools.every(name => names.includes(name));
+
+  const opened = structured(await client.callTool({ name: 'workspace_open', arguments: { workspace_id: 'demo' } }), 'workspace_open');
+  if (opened.status !== 'ok') throw new Error(`workspace_open status=${String(opened.status)}`);
+
+  const proofOutput = `remote-proof.${randomBytes(8).toString('hex')}.txt`;
+  const proof = structured(await client.callTool({
+    name: 'proof_execute', arguments: { workspace_id: 'demo', input: 'input.txt', output: proofOutput }
+  }), 'proof_execute');
+  if (proof.status !== 'passed' || !/^[0-9a-f]{64}$/.test(proof.request_sha256)) throw new Error('remote proof request identity missing');
+  const proofVerify = structured(await client.callTool({
+    name: 'evidence_verify', arguments: { workspace_id: 'demo', receipt_path: proof.receipt_path }
+  }), 'evidence_verify proof');
+  if (proofVerify.ok !== true || proofVerify.signature_valid !== true || proofVerify.receipt_schema !== 'deadbyte.receipt.v2' ||
+      proofVerify.request_sha256 !== proof.request_sha256) throw new Error(`remote proof verify failed: ${JSON.stringify(proofVerify)}`);
+
+  let contained = null;
+  if (mode === 'full') {
+    const output = `remote-contained.${randomBytes(8).toString('hex')}.txt`;
+    const exec = structured(await client.callTool({
+      name: 'contained_transform',
+      arguments: { workspace_id: 'demo', input: 'input.txt', output, operation: 'uppercase_ascii' }
+    }), 'contained_transform');
+    if (exec.status !== 'passed' || exec.output_sha256 !== '3e740f6fcf2c6659bc5f99e0706b09f3c127407bbabe74d05285d2e3276946c2' ||
+        !/^[0-9a-f]{64}$/.test(exec.request_sha256)) throw new Error(`remote contained result mismatch: ${JSON.stringify(exec)}`);
+    const verify = structured(await client.callTool({
+      name: 'evidence_verify', arguments: { workspace_id: 'demo', receipt_path: exec.receipt_path }
+    }), 'evidence_verify contained');
+    if (verify.ok !== true || verify.signature_valid !== true || verify.containment_verified !== true ||
+        verify.active_network_denial_verified !== true || verify.receipt_schema !== 'deadbyte.receipt.v2' ||
+        verify.request_sha256 !== exec.request_sha256) throw new Error(`remote contained verification failed: ${JSON.stringify(verify)}`);
+    contained = { output, receipt_sha256: exec.receipt_sha256, request_sha256: exec.request_sha256, output_sha256: exec.output_sha256 };
+  }
+  let agent = null;
+  if (mode === 'full' && agentRuntime) {
+    const submissionId = `remote-gate-${randomBytes(8).toString('hex')}`;
+    const submitted = structured(await client.callTool({
+      name: 'agent_task_submit', arguments: {
+        workspace_id: 'demo', submission_id: submissionId, title: 'remote R22 gate',
+        steps: [
+          { step_id: 'proof', kind: 'proof_execute', input: { kind: 'workspace', path: 'input.txt' }, retry_limit: 0 },
+          { step_id: 'contained', kind: 'contained_transform', operation: 'uppercase_ascii', input: { kind: 'step_output', step_id: 'proof' }, retry_limit: 0 }
+        ]
+      }
+    }), 'agent_task_submit');
+    const run = structured(await client.callTool({
+      name: 'agent_task_run', arguments: { workspace_id: 'demo', task_id: submitted.task_id, max_steps: 8 }
+    }), 'agent_task_run');
+    if (run.state !== 'succeeded' || run.completed_steps !== 2) throw new Error(`agent task run failed: ${JSON.stringify(run)}`);
+    const verified = structured(await client.callTool({
+      name: 'agent_task_verify', arguments: { workspace_id: 'demo', task_id: submitted.task_id }
+    }), 'agent_task_verify');
+    if (verified.ok !== true || verified.signature_valid !== true || verified.step_receipts_verified !== 2) {
+      throw new Error(`agent task verify failed: ${JSON.stringify(verified)}`);
+    }
+    agent = { task_id: submitted.task_id, plan_sha256: submitted.plan_sha256,
+      task_receipt_sha256: verified.task_receipt_sha256, step_receipts_verified: verified.step_receipts_verified };
+  }
+  console.log(JSON.stringify({
+    status: 'passed', mode,
+    protocol_revision: '2026-07-28', protocol_era: 'modern', tools: names,
+    output_schemas_strict: true,
+    machine_runtime: machineRuntime, privileged_host_plane: privilegedHostPlane,
+    agent_runtime: agentRuntime, process_runtime: processRuntime,
+    machine_fs_runtime: machineFsRuntime, observation_runtime: observationRuntime,
+    coding_runtime: codingRuntime, autonomous_runtime: autonomousRuntime,
+    proof: { output: proofOutput, receipt_sha256: proof.receipt_sha256,
+      request_sha256: proof.request_sha256, signature_valid: true },
+    contained, agent
+  }, null, 2));
+} finally {
+  await client.close().catch(() => {});
+}

package/src/request-identity.mjs

@@ -0,0 +1,63 @@
+import { randomBytes } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+import { sha256Bytes } from './hash.mjs';
+import { RECEIPT_REQUEST_SCHEMA } from './version.mjs';
+
+const HEX64 = /^[0-9a-f]{64}$/;
+
+export function validateRequestIdentity(request, expected) {
+  if (!request || request.schema !== RECEIPT_REQUEST_SCHEMA) throw new Error('request schema mismatch');
+  if (!HEX64.test(request.nonce)) throw new Error('request nonce invalid');
+  if (!HEX64.test(request.sha256)) throw new Error('request digest invalid');
+  if (request.operation !== expected.operation || request.input_sha256 !== expected.inputSha256 ||
+      request.worker_id !== expected.workerId || request.worker_sha256 !== expected.workerSha256) {
+    throw new Error('request identity binding mismatch');
+  }
+  const { sha256: claimed, ...body } = request;
+  if (sha256Bytes(Buffer.from(canonicalJson(body), 'utf8')) !== claimed) throw new Error('request digest mismatch');
+  if (expected.containedInvocation) {
+    const bound = request.contained_invocation;
+    if (!bound || bound.schema !== expected.containedInvocation.schema ||
+        bound.challenge !== expected.containedInvocation.challenge ||
+        bound.request_sha256 !== expected.containedInvocation.requestSha256) {
+      throw new Error('request contained invocation binding mismatch');
+    }
+  } else if (request.contained_invocation !== undefined) {
+    throw new Error('unexpected request contained invocation');
+  }
+  return true;
+}
+
+export function createRequestIdentity({ operation, inputSha256, workerId, workerSha256, containedInvocation = undefined }) {
+  if (typeof operation !== 'string' || operation.length === 0) throw new Error('request operation missing');
+  if (!HEX64.test(inputSha256)) throw new Error('request input hash invalid');
+  if (typeof workerId !== 'string' || workerId.length === 0) throw new Error('request worker id missing');
+  if (!HEX64.test(workerSha256)) throw new Error('request worker hash invalid');
+
+  if (containedInvocation !== undefined) {
+    if (containedInvocation.schema !== 'deadbyte.invocation.v1' || !HEX64.test(containedInvocation.challenge) || !HEX64.test(containedInvocation.requestSha256)) {
+      throw new Error('contained invocation identity invalid');
+    }
+  }
+
+  const body = {
+    schema: RECEIPT_REQUEST_SCHEMA,
+    nonce: randomBytes(32).toString('hex'),
+    operation,
+    input_sha256: inputSha256,
+    worker_id: workerId,
+    worker_sha256: workerSha256,
+    ...(containedInvocation === undefined ? {} : {
+      contained_invocation: {
+        schema: containedInvocation.schema,
+        challenge: containedInvocation.challenge,
+        request_sha256: containedInvocation.requestSha256
+      }
+    })
+  };
+
+  return Object.freeze({
+    ...body,
+    sha256: sha256Bytes(Buffer.from(canonicalJson(body), 'utf8'))
+  });
+}

package/src/runtime-identity.mjs

@@ -0,0 +1,33 @@
+import { randomBytes } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { sha256File } from './hash.mjs';
+import { DEADBYTE_VERSION, MCP_PROTOCOL_VERSION, RUNTIME_IDENTITY_SCHEMA } from './version.mjs';
+import { currentIngressAdapterMode } from './ingress-mode.mjs';
+
+const mcpServerPath = fileURLToPath(new URL('./mcp-server.mjs', import.meta.url));
+const ingressAdapterPath = fileURLToPath(new URL('./tunnel-stdio-compat.mjs', import.meta.url));
+const ingressModePath = fileURLToPath(new URL('./ingress-mode.mjs', import.meta.url));
+const instanceNonce = randomBytes(32).toString('hex');
+let cached;
+
+export async function runtimeIdentity() {
+  if (!cached) {
+    cached = Object.freeze({
+      schema: RUNTIME_IDENTITY_SCHEMA,
+      package_version: DEADBYTE_VERSION,
+      mcp_protocol_version: MCP_PROTOCOL_VERSION,
+      instance_nonce: instanceNonce,
+      pid: process.pid,
+      node_version: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      mcp_server_sha256: await sha256File(mcpServerPath),
+      mcp_ingress_adapter: currentIngressAdapterMode(),
+      mcp_ingress_adapter_sha256: await sha256File(ingressAdapterPath),
+      mcp_ingress_mode_source_sha256: await sha256File(ingressModePath)
+    });
+  }
+  return cached;
+}
+
+export const runtimeIdentityPaths = Object.freeze({ mcpServerPath, ingressAdapterPath, ingressModePath });