deadbyte-mcp 0.11.3 → 0.13.0

package/src/desktop-uia-r40.mjs

@@ -0,0 +1,123 @@
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export const DESKTOP_UIA_GROUND_SCHEMA='deadbyte.desktop-uia-ground.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const HWND=/^0x[0-9a-f]{1,16}$/;
+const QUERY_KINDS=new Set(['root','name_exact','name_contains','automation_id_exact','control_type']);
+const sha256Bytes=value=>createHash('sha256').update(value).digest('hex');
+
+function insist(c,m){if(!c)throw new Error(m);}
+function integer(v,label,{min=Number.MIN_SAFE_INTEGER,max=Number.MAX_SAFE_INTEGER}={}){
+  insist(Number.isSafeInteger(v)&&v>=min&&v<=max,label+' invalid');return v;
+}
+function hwnd(v){const s=String(v??'').toLowerCase();insist(HWND.test(s),'desktop UIA hwnd invalid');return s;}
+function queryInput(query){
+  insist(query&&typeof query==='object'&&!Array.isArray(query),'desktop UIA query invalid');
+  const kind=String(query.kind??'');
+  insist(QUERY_KINDS.has(kind),'desktop UIA query kind invalid');
+  const value=query.value??'';
+  insist(typeof value==='string'&&!value.includes('\0'),'desktop UIA query value invalid');
+  const bytes=Buffer.from(value,'utf8');
+  if(kind==='root') insist(bytes.length===0,'desktop UIA root query cannot carry value');
+  else insist(bytes.length>=1&&bytes.length<=512,'desktop UIA query value bytes invalid');
+  const maxResults=integer(query.max_results??8,'desktop UIA max_results',{min:1,max:16});
+  const ordinal=integer(query.ordinal??0,'desktop UIA ordinal',{min:0,max:maxResults-1});
+  const querySha256=sha256Bytes(Buffer.from(JSON.stringify({kind,value,max_results:maxResults,ordinal}),'utf8'));
+  return {kind,value,bytes,maxResults,ordinal,querySha256};
+}
+
+export function serializeDesktopUiaRequest({expectedWindow,query}={}){
+  insist(expectedWindow&&typeof expectedWindow==='object','desktop UIA expected window missing');
+  const expectedHwnd=hwnd(expectedWindow.hwnd);
+  const expectedPid=integer(expectedWindow.pid,'desktop UIA expected pid',{min:1,max:0x7fffffff});
+  const q=queryInput(query);
+  const header=Buffer.from([
+    'DEADBYTE_DESKTOP_UIA_V1',
+    'expected_hwnd='+expectedHwnd,
+    'expected_pid='+expectedPid,
+    'query_kind='+q.kind,
+    'max_results='+q.maxResults,
+    'query_bytes='+q.bytes.length,
+    ''
+  ].join('\n'),'utf8');
+  const request=Buffer.concat([header,q.bytes]);
+  insist(request.length<=8192,'desktop UIA request exceeds bound');
+  return {request,query:q};
+}
+
+export function parseDesktopUiaResponse(bytes,{expectedWindow,query,expectedBounds}={}){
+  insist(Buffer.isBuffer(bytes)&&bytes.length>=2&&bytes.length<=256*1024,'desktop UIA response invalid');
+  let raw;try{raw=JSON.parse(bytes.toString('utf8').trim());}catch{throw new Error('desktop UIA response JSON invalid');}
+  insist(raw?.schema===DESKTOP_UIA_GROUND_SCHEMA,'desktop UIA response schema mismatch');
+  const q=queryInput(query);
+  insist(String(raw.query_kind)===q.kind,'desktop UIA response query mismatch');
+  insist(hwnd(raw.foreground_hwnd)===hwnd(expectedWindow.hwnd),'desktop UIA response hwnd mismatch');
+  insist(integer(raw.foreground_pid,'desktop UIA response pid',{min:1,max:0x7fffffff})===expectedWindow.pid,'desktop UIA response pid mismatch');
+  integer(raw.visited,'desktop UIA visited',{min:0,max:2048});
+  insist(typeof raw.truncated==='boolean','desktop UIA truncated invalid');
+  insist(Array.isArray(raw.matches)&&raw.matches.length<=q.maxResults,'desktop UIA matches invalid');
+  const left=integer(expectedBounds.left,'desktop UIA bounds left',{min:-131072,max:131072});
+  const top=integer(expectedBounds.top,'desktop UIA bounds top',{min:-131072,max:131072});
+  const width=integer(expectedBounds.width,'desktop UIA bounds width',{min:1,max:131072});
+  const height=integer(expectedBounds.height,'desktop UIA bounds height',{min:1,max:131072});
+  const matches=[];
+  for(const item of raw.matches){
+    const rect={
+      left:integer(item.left,'desktop UIA rect left',{min:-131072,max:131072}),
+      top:integer(item.top,'desktop UIA rect top',{min:-131072,max:131072}),
+      width:integer(item.width,'desktop UIA rect width',{min:1,max:131072}),
+      height:integer(item.height,'desktop UIA rect height',{min:1,max:131072})
+    };
+    const inside=rect.left>=left&&rect.top>=top&&rect.left+rect.width<=left+width&&rect.top+rect.height<=top+height;
+    if(!inside) continue;
+    matches.push(Object.freeze({
+      rect:Object.freeze(rect),
+      control_type:integer(item.control_type,'desktop UIA control_type',{min:0,max:100000}),
+      enabled:item.enabled===true,offscreen:item.offscreen===true
+    }));
+  }
+  return Object.freeze({
+    status:'ok',query_sha256:q.querySha256,query_kind:q.kind,ordinal:q.ordinal,
+    visited:raw.visited,truncated:raw.truncated,matches:Object.freeze(matches),
+    provider_receipt_sha256:sha256Bytes(bytes)
+  });
+}
+
+export async function invokeNativeDesktopGrounder({grounderPath,expectedGrounderSha256,timeoutMs=5000,expectedWindow,expectedBounds,query}={}){
+  insist(typeof grounderPath==='string'&&path.isAbsolute(grounderPath),'desktop grounderPath must be absolute');
+  insist(HEX64.test(expectedGrounderSha256??''),'desktop expectedGrounderSha256 invalid');
+  integer(timeoutMs,'desktop UIA timeoutMs',{min:100,max:30000});
+  const exe=await readFile(grounderPath);
+  insist(exe.length>0&&exe.length<=4*1024*1024,'desktop UIA binary size invalid');
+  insist(sha256Bytes(exe)===expectedGrounderSha256,'desktop UIA executable hash mismatch');
+  const packed=serializeDesktopUiaRequest({expectedWindow,query});
+  return await new Promise((resolve,reject)=>{
+    const child=spawn(grounderPath,[],{shell:false,windowsHide:true,stdio:['pipe','pipe','pipe']});
+    const stdout=[];let bytes=0,stderr='',done=false,timer=null;
+    const finish=(error,value)=>{if(done)return;done=true;if(timer!==null)clearTimeout(timer);error?reject(error):resolve(value);};
+    child.stdout.on('data',chunk=>{bytes+=chunk.length;if(bytes>256*1024){try{child.kill('SIGKILL');}catch{};return finish(new Error('desktop UIA stdout exceeds bound'));}stdout.push(Buffer.from(chunk));});
+    child.stderr.on('data',chunk=>{stderr+=chunk.toString('utf8');if(Buffer.byteLength(stderr,'utf8')>64*1024){try{child.kill('SIGKILL');}catch{};finish(new Error('desktop UIA stderr exceeds bound'));}});
+    child.once('error',error=>finish(error));
+    child.once('exit',(code,signal)=>{
+      if(code!==0)return finish(new Error('desktop UIA exit='+code+' signal='+(signal??'none')+' stderr='+stderr.slice(-8192)));
+      try{finish(null,parseDesktopUiaResponse(Buffer.concat(stdout),{expectedWindow,query,expectedBounds}));}
+      catch(error){finish(error);}
+    });
+    child.stdin.on('error',error=>finish(error));
+    child.stdin.end(packed.request);
+    timer=setTimeout(()=>{try{child.kill('SIGKILL');}catch{};finish(new Error('desktop UIA timed out after '+timeoutMs+'ms'));},timeoutMs);
+  });
+}
+
+export function createNativeDesktopGrounder({grounderPath,expectedGrounderSha256,timeoutMs=5000}={}){
+  return async({frame,query}={})=>{
+    insist(frame?.active_window,'desktop UIA grounding requires foreground window');
+    return invokeNativeDesktopGrounder({
+      grounderPath,expectedGrounderSha256,timeoutMs,
+      expectedWindow:frame.active_window,expectedBounds:frame.bounds,query
+    });
+  };
+}

package/src/mcp-server.mjs

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { access, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -9,7 +10,7 @@ import { executeProof } from './executor.mjs';
 import { CONTAINED_TRANSFORM_OPERATIONS, executeContainedTransform } from './contained-executor.mjs';
 import { resolveExistingInside, resolveWorkspace } from './path-policy.mjs';
 import { verifyReceipt } from './verifier.mjs';
-import { defaultPrivateKeyPath, defaultPublicKeyPath } from './trust.mjs';
+import { defaultPrivateKeyPath, defaultPublicKeyPath, loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
 import { currentIngressAdapterMode, TUNNEL_STDIO_PROBE_COMPAT_MODE } from './ingress-mode.mjs';
 import { installTunnelStdioProbeCompat } from './tunnel-stdio-compat.mjs';
@@ -31,6 +32,14 @@ import { createMachineFsRuntime } from './machine-fs.mjs';
 import { registerMachineFsTools } from './machine-fs-mcp-tools.mjs';
 import { createObservationRuntime } from './observation-runtime.mjs';
 import { registerObservationTools } from './observation-mcp-tools.mjs';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { createDesktopObserverRuntime } from './desktop-observer-r40.mjs';
+import { createNativeDesktopInputProvider } from './desktop-input-r40.mjs';
+import { createNativeDesktopGrounder } from './desktop-uia-r40.mjs';
+import { createDesktopRuntime } from './desktop-runtime-r40.mjs';
+import { createDesktopMemoryProvider } from './desktop-memory-r40.mjs';
+import { createR41MemoryProvider } from './memory-r41.mjs';
+import { registerDesktopTools } from './desktop-mcp-tools-r40.mjs';
 import { loadAutonomousPolicy } from './autonomous-policy.mjs';
 import { createNativeDiffRuntime } from './native-diff.mjs';
 import { createAutonomousRuntime } from './autonomous-runtime.mjs';
@@ -54,6 +63,7 @@ import {
 } from './output-contracts.mjs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageManifestSha256=createHash('sha256').update(await readFile(path.join(packageRoot,'MANIFEST.SHA256'))).digest('hex');
 const workspaceRoot = path.resolve(process.env.DEADBYTE_WORKSPACE_ROOT ?? path.join(packageRoot, 'workspaces'));
 const signingKeyPath = process.env.DEADBYTE_SIGNING_KEY ?? defaultPrivateKeyPath();
 const verifyKeyPath = process.env.DEADBYTE_VERIFY_KEY ?? defaultPublicKeyPath();
@@ -125,6 +135,44 @@ const observationRuntime = observationRuntimeMode === '1'
       stateRoot: runtimeStateRoot })
   : null;
 
+const desktopRuntimeMode=process.env.DEADBYTE_DESKTOP_RUNTIME??'0';
+if(!['0','1'].includes(desktopRuntimeMode)) throw new Error('DEADBYTE_DESKTOP_RUNTIME must be 0 or 1');
+const localDesktopPolicyPath=path.join(packageRoot,'controller','deadbyte-desktop-policy.json');
+let desktopPolicyPath=process.env.DEADBYTE_DESKTOP_POLICY??'';
+if(desktopRuntimeMode==='1'&&!desktopPolicyPath){
+  try{await access(localDesktopPolicyPath);desktopPolicyPath=localDesktopPolicyPath;}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+}
+if(desktopRuntimeMode==='1'&&!desktopPolicyPath) throw new Error('DEADBYTE_DESKTOP_RUNTIME=1 requires a desktop policy');
+const desktopPolicy=desktopRuntimeMode==='1'?await loadDesktopPolicy(desktopPolicyPath):null;
+const desktopObserverRuntime=desktopPolicy?createDesktopObserverRuntime({
+  observerPath:desktopPolicy.observer.executable,expectedObserverSha256:desktopPolicy.observer.sha256,
+  maxFrameBytes:desktopPolicy.limits.max_frame_bytes,timeoutMs:desktopPolicy.limits.capture_timeout_ms,
+  allowInputDesktops:desktopPolicy.allowed_input_desktops
+}):null;
+const desktopInputProvider=desktopPolicy?createNativeDesktopInputProvider({
+  inputPath:desktopPolicy.input.executable,expectedInputSha256:desktopPolicy.input.sha256,
+  timeoutMs:desktopPolicy.limits.input_timeout_ms
+}):null;
+const desktopGrounderProvider=desktopPolicy?createNativeDesktopGrounder({
+  grounderPath:desktopPolicy.grounder.executable,expectedGrounderSha256:desktopPolicy.grounder.sha256,
+  timeoutMs:desktopPolicy.limits.ground_timeout_ms
+}):null;
+const desktopSigningKey=desktopPolicy?await loadPrivateSigningKey(signingKeyPath):null;
+const desktopVerifyKey=desktopPolicy?await loadPublicVerifyKey(verifyKeyPath):null;
+if(desktopPolicy&&desktopSigningKey.keyId!==desktopVerifyKey.keyId) throw new Error('Desktop signing/verify key mismatch');
+const desktopRuntime=desktopPolicy?createDesktopRuntime({
+  policy:desktopPolicy,observerRuntime:desktopObserverRuntime,inputProvider:desktopInputProvider,
+  grounderProvider:desktopGrounderProvider,
+  privateKey:desktopSigningKey.privateKey,publicKey:desktopVerifyKey.publicKey,keyId:desktopSigningKey.keyId
+}):null;
+const desktopMemoryProvider=desktopPolicy?createDesktopMemoryProvider({
+  evidenceDir:desktopPolicy.evidence_dir,
+  snapshotPath:path.join(desktopPolicy.evidence_dir,'desktop-memory.json'),
+  policySha256:desktopPolicy.policy_sha256,
+  privateKey:desktopSigningKey.privateKey,publicKey:desktopVerifyKey.publicKey,keyId:desktopSigningKey.keyId
+}):null;
+
 const autonomousRuntimeMode = process.env.DEADBYTE_AUTONOMOUS_RUNTIME ?? '0';
 if (!['0','1'].includes(autonomousRuntimeMode)) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME must be 0 or 1');
 const autonomousSupervisorMode = process.env.DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE ?? 'in_process';
@@ -142,8 +190,18 @@ if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) throw new Error('DEA
 const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy) : null;
 const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
 semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
+const autonomousMemorySigningKey=autonomousPolicy?await loadPrivateSigningKey(signingKeyPath):null;
+const autonomousMemoryVerifyKey=autonomousPolicy?await loadPublicVerifyKey(verifyKeyPath):null;
+if(autonomousPolicy&&autonomousMemorySigningKey.keyId!==autonomousMemoryVerifyKey.keyId) throw new Error('R41 memory signing/verify key mismatch');
+const memoryProvider=autonomousPolicy?createR41MemoryProvider({
+  memoryRoot:path.join(autonomousPolicy.evidence_dir,'memory-r41',packageManifestSha256),sourceReleaseManifest:packageManifestSha256,
+  journalRoot:path.join(autonomousPolicy.evidence_dir,'goals'),
+  writerVersion:DEADBYTE_VERSION,privateKey:autonomousMemorySigningKey.privateKey,
+  publicKey:autonomousMemoryVerifyKey.publicKey,keyId:autonomousMemorySigningKey.keyId,
+  byteBudget:Math.min(262144,Math.max(65536,Math.floor(autonomousPolicy.limits.max_context_bytes/2))),semantic:{enabled:false}
+}):null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,signingKeyPath,verifyKeyPath }) : null;
+  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,memoryProvider,signingKeyPath,verifyKeyPath }) : null;
 const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
@@ -185,11 +243,17 @@ function filteredToolServer(server,allowed){
 
 serveStdio(() => {
   const server = new McpServer({ name: 'deadbyte-mcp', version: DEADBYTE_VERSION });
+  const registeredToolNames=new Set();
+  const toolServer={registerTool(name,...args){
+    if(registeredToolNames.has(name)) throw new Error(`duplicate tool registration: ${name}`);
+    registeredToolNames.add(name);
+    return server.registerTool(name,...args);
+  }};
   registerOperatorSurface(server,{packageRoot,surfaceProfile,compactToolLimit:COMPACT_SURFACE_TOOL_LIMIT});
   if (toolAudit) installToolAudit(server,toolAudit);
 
   if (surfaceProfile === 'full') {
-  server.registerTool(
+  toolServer.registerTool(
     'workspace_open',
     {
       description: 'Open a named workspace below the configured DEADBYTE workspace root.',
@@ -206,7 +270,7 @@ serveStdio(() => {
     }
   );
 
-  server.registerTool(
+  toolServer.registerTool(
     'file_read',
     {
       description: 'Read one UTF-8 file inside a named workspace. Path traversal and symlink escape are denied.',
@@ -229,7 +293,7 @@ serveStdio(() => {
     }
   );
 
-  server.registerTool(
+  toolServer.registerTool(
     'proof_execute',
     {
       description: 'Run the fixed DEADBYTE V0 proof worker inside one workspace and produce an Ed25519-signed hashed receipt. This is not a general shell.',
@@ -263,7 +327,7 @@ serveStdio(() => {
     }
   );
 
-  server.registerTool(
+  toolServer.registerTool(
     'contained_transform',
     {
       description: 'Run one compile-time allowlisted ASCII transform inside the proven Windows AppContainer + atomic Job boundary. Input is copied into a private sandbox profile; the host workspace is never mounted. This is not a shell and does not accept an executable path.',
@@ -306,7 +370,7 @@ serveStdio(() => {
 
   }
 
-  server.registerTool(
+  toolServer.registerTool(
     'evidence_verify',
     {
       description: 'Independently verify Ed25519 receipt authenticity and recompute file, stream, and worker hashes.',
@@ -327,7 +391,7 @@ serveStdio(() => {
   );
 
   if (machineRuntime) {
-    registerMachineTools(server, {
+    registerMachineTools(toolServer, {
       runtime: machineRuntime,
       assertRevokeAuthority: async () => {
         if (!hostPolicy) throw new Error('privileged host plane is not configured');
@@ -337,37 +401,41 @@ serveStdio(() => {
   }
 
   if (agentRuntime && surfaceProfile === 'full') {
-    registerAgentTools(server, { runtime: agentRuntime, workspacePathFromId });
+    registerAgentTools(toolServer, { runtime: agentRuntime, workspacePathFromId });
   }
 
   if (processRuntime && surfaceProfile === 'full') {
-    registerProcessTools(server, { runtime: processRuntime });
+    registerProcessTools(toolServer, { runtime: processRuntime });
   }
 
   if (codingRuntime && codingTaskRuntime && semanticRuntime) {
-    const codingServer=surfaceProfile==='full'?server:filteredToolServer(server,COMPACT_CODING_DIRECT_TOOLS);
+    const codingServer=surfaceProfile==='full'?toolServer:filteredToolServer(toolServer,COMPACT_CODING_DIRECT_TOOLS);
     registerCodingTools(codingServer, { codingRuntime, taskRuntime: codingTaskRuntime, semanticRuntime });
   }
 
   if (machineFsRuntime && surfaceProfile === 'full') {
-    registerMachineFsTools(server, { runtime: machineFsRuntime });
+    registerMachineFsTools(toolServer, { runtime: machineFsRuntime });
   }
 
   if (observationRuntime && surfaceProfile === 'full') {
-    registerObservationTools(server, { runtime: observationRuntime });
+    registerObservationTools(toolServer, { runtime: observationRuntime });
+  }
+
+  if (desktopRuntime && surfaceProfile === 'full') {
+    registerDesktopTools(toolServer,{runtime:desktopRuntime});
   }
 
   if (autonomousRuntime && nativeDiffRuntime) {
-    registerAutonomousTools(server, { autonomousRuntime, nativeDiffRuntime });
+    registerAutonomousTools(toolServer, { autonomousRuntime, nativeDiffRuntime });
   }
 
-  registerCompactGatewayTools(server,{
+  registerCompactGatewayTools(toolServer,{
     profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
-    processRuntime,observationRuntime,machineRuntime
+    processRuntime,observationRuntime,machineRuntime,desktopRuntime,catalogProvider:()=>[...registeredToolNames]
   });
 
   if (hostPolicy) {
-    server.registerTool(
+    toolServer.registerTool(
       'host_file_read',
       {
         description: 'Privileged host-plane read from a locally allowlisted root. Requires a live local arm lease; path traversal and symlink escape are denied.',
@@ -388,7 +456,7 @@ serveStdio(() => {
       }
     );
 
-    server.registerTool(
+    toolServer.registerTool(
       'host_file_write',
       {
         description: 'Privileged host-plane hash-precondition file write inside a locally allowlisted root. Commit is same-directory atomic rename and post-commit SHA-256 verified. Requires a live local arm lease.',
@@ -417,7 +485,7 @@ serveStdio(() => {
       }
     );
 
-    server.registerTool(
+    toolServer.registerTool(
       'host_exec',
       {
         description: 'Privileged host-plane script execution through a locally allowlisted and SHA-256-pinned executable. No raw shell command string is accepted. Requires a live local arm lease.',