@botbuddy/cli 1.63.13 → 1.63.15

package/src/stack-requester-origin.mjs

@@ -0,0 +1,62 @@
+// BOT-2780: one requester listener, reserved before a service generates URLs.
+// The CLI later binds it to exactly one API port on its owned SSH tunnel. This
+// listener is not itself an SSH forward and never supplies forward attestation.
+import {createServer,connect} from 'node:net';
+
+const fail=(code,message)=>{const error=Error(message);error.code=code;throw error};
+const validPort=value=>Number.isInteger(value)&&value>=1024&&value<=65535;
+const identity=value=>typeof value==='string'&&value.length>0&&value.length<=4096&&!/[\x00-\x1f\x7f]/.test(value);
+function contextSnapshot(value){
+ if(!value||typeof value!=='object'||Array.isArray(value)||!Object.isFrozen(value))fail('REQUESTER_ORIGIN_CONTEXT_REFUSED','immutable requester context required');
+ const keys=Object.keys(value).sort();if(!keys.length||keys.length>16||keys.some(key=>!identity(key)||!identity(value[key])))fail('REQUESTER_ORIGIN_CONTEXT_REFUSED','requester context refused');
+ return JSON.stringify(keys.map(key=>[key,value[key]]));
+}
+function apiPort(value){
+ let url;try{url=new URL(value)}catch{fail('REQUESTER_ORIGIN_FORWARD_REFUSED','owned API URL unavailable')}
+ if(url.protocol!=='http:'||url.hostname!=='127.0.0.1'||url.username||url.password||url.pathname!=='/'||url.search||url.hash||!validPort(Number(url.port)))fail('REQUESTER_ORIGIN_FORWARD_REFUSED','API target must be the owned loopback HTTP endpoint');
+ return Number(url.port);
+}
+export async function reserveRequesterOrigin({context,port=0}={}){
+ const snapshot=contextSnapshot(context);if(port!==0&&!validPort(port))fail('REQUESTER_ORIGIN_PORT_REFUSED','requester origin port refused');
+ const sockets=new Set(),lossListeners=new Set();let route,closed=false,lostCode,closePromise;
+ const live=()=>{try{return !closed&&route?.isLive()===true}catch{return false}};
+ const close=code=>{
+  if(closePromise)return closePromise;closed=true;lostCode=code??lostCode;
+  for(const socket of sockets)socket.destroy();sockets.clear();
+  closePromise=new Promise(resolve=>server.close(()=>resolve()));
+  if(code)for(const listener of lossListeners){try{listener({code})}catch{}}
+  return closePromise;
+ };
+ const server=createServer({pauseOnConnect:true},socket=>{
+  if(!route){socket.destroy();return}
+  if(!live()){socket.destroy();void close('REQUESTER_ORIGIN_TUNNEL_LOST');return}
+  sockets.add(socket);const upstream=connect({host:'127.0.0.1',port:route.targetPort});sockets.add(upstream);
+  socket.once('error',()=>upstream.destroy());socket.once('close',()=>{sockets.delete(socket);upstream.destroy()});upstream.once('close',()=>sockets.delete(upstream));
+  upstream.once('error',()=>{socket.destroy();void close('REQUESTER_ORIGIN_FORWARD_LOST')});
+  upstream.once('connect',()=>{
+   if(!live()){socket.destroy();upstream.destroy();void close('REQUESTER_ORIGIN_TUNNEL_LOST');return}
+   // Pipe only after rechecking custody at connect time. Request paths, auth,
+   // bodies and WebSocket upgrade bytes are transparent; there is no URL target.
+   socket.pipe(upstream);upstream.pipe(socket);socket.resume();
+  });
+ });
+ server.maxConnections=64;
+ try{await new Promise((resolve,reject)=>{server.once('error',reject);server.listen({host:'127.0.0.1',port,exclusive:true},resolve)})}catch(error){await close();fail(error.code==='EADDRINUSE'?'REQUESTER_ORIGIN_PORT_BUSY':'REQUESTER_ORIGIN_BIND_FAILED','requester origin could not be reserved')}
+ const boundPort=server.address().port;server.on('error',()=>{void close('REQUESTER_ORIGIN_BIND_FAILED')});
+ return{
+  origin:'http://127.0.0.1:'+boundPort,
+  activate({context:current,leaseId,projectId,sshTarget,remoteConnection,forwardedConnection,forwards,isLive,watchLoss}={}){
+   if(closed||route)fail('REQUESTER_ORIGIN_STATE_REFUSED','requester origin cannot be rebound in place');
+   if(contextSnapshot(current)!==snapshot||![leaseId,projectId,sshTarget].every(identity)||typeof isLive!=='function'||typeof watchLoss!=='function')fail('REQUESTER_ORIGIN_CONTEXT_REFUSED','owned current lease/forward context required');
+   const remote=apiPort(remoteConnection?.api_url),local=apiPort(forwardedConnection?.api_url);
+   if(!Array.isArray(forwards)||forwards.length<1||forwards.length>32||forwards.some(row=>!identity(row?.name)||!validPort(row.remote)||!validPort(row.local))||['name','remote','local'].some(key=>new Set(forwards.map(row=>row[key])).size!==forwards.length))fail('REQUESTER_ORIGIN_FORWARD_REFUSED','SSH forward table refused');
+   const api=forwards.find(row=>row.remote===remote);if(!api||api.local!==local||local===boundPort)fail('REQUESTER_ORIGIN_FORWARD_REFUSED','API URL differs from actual SSH forward');
+   if(isLive()!==true)fail('REQUESTER_ORIGIN_TUNNEL_LOST','owned SSH tunnel is not live');
+   route=Object.freeze({leaseId,projectId,sshTarget,targetPort:local,isLive});
+   try{watchLoss(()=>{void close('REQUESTER_ORIGIN_TUNNEL_LOST')})}catch{void close('REQUESTER_ORIGIN_TUNNEL_LOST');fail('REQUESTER_ORIGIN_TUNNEL_LOST','owned SSH loss subscription unavailable')}
+   if(!live()){void close('REQUESTER_ORIGIN_TUNNEL_LOST');fail('REQUESTER_ORIGIN_TUNNEL_LOST','owned SSH tunnel ended during activation')}
+  },
+  close:()=>close(),isLive:live,
+  onLost(listener){lossListeners.add(listener);if(lostCode)listener({code:lostCode})},
+ };
+}

package/src/stack-tunnel.mjs

@@ -469,7 +469,7 @@ export async function probeGatewayPorts({
  * @returns {{ forwards, connection, argv, attempts, onExit, close, pid }}
  */
 export async function establishSshTunnel({
-  connection, sshTarget, hostKey = null, callbackPort = null, sshBin = null, env = process.env,
+  connection, sshTarget, hostKey = null, callbackPort = null, reserveLocalPorts = [], sshBin = null, env = process.env,
   attempts = 3, readyTimeoutMs = DEFAULT_TUNNEL_READY_MS, isFree = isLocalPortFree, pickFree = pickFreeLocalPort, spawnImpl = spawn,
   runRemote = spawnSync, probe = probeGatewayPorts, probeReadyTimeoutMs = DEFAULT_PROBE_READY_MS,
 }) {
@@ -500,7 +500,9 @@ export async function establishSshTunnel({
   }
   // Codex #1134 P2: a remapped stack forward must never take the callback port locally; ssh
   // would bind it before the caller's callback service and the -R traffic would loop into it.
-  let avoid = new Set(callbackPort != null ? [Number(callbackPort)] : []);
+  // BOT-2775 (Codex #1402 P2): a native-callback run opens no -R, but its child still serves the
+  // callback on that requester port, so the planner keeps it reserved via reserveLocalPorts.
+  let avoid = new Set([...(callbackPort != null ? [Number(callbackPort)] : []), ...reserveLocalPorts.map(Number)]);
   let lastError = null;
   for (let attempt = 1; attempt <= attempts; attempt++) {
     const forwards = await planForwards(remotePorts, { isFree, pickFree, avoid });