|
import assert from "node:assert/strict"; |
|
import fs from "node:fs"; |
|
import path from "node:path"; |
|
import os from "node:os"; |
|
import http from "node:http"; |
|
import crypto from "node:crypto"; |
|
import {spawn,execFileSync} from "node:child_process"; |
|
import {createRequire} from "node:module"; |
|
import {pathToFileURL} from "node:url"; |
|
const phase = process.argv[2]; |
|
assert.ok(["baseline","fixed"].includes(phase)); |
|
const checkout = process.cwd(); |
|
const requireLocal = createRequire(path.join(checkout,"apps/server/package.json")); |
|
const local = name => import(pathToFileURL(requireLocal.resolve(name)).href); |
|
const [Effect,Layer,Stream,Deferred,{Socket},{RpcClient,RpcSerialization},contracts] = await Promise.all([ |
|
local("effect/Effect"),local("effect/Layer"),local("effect/Stream"),local("effect/Deferred"),local("effect/socket"),local("effect/rpc"),import(pathToFileURL(path.join(checkout,"packages/contracts/src/index.ts")).href) |
|
]); |
|
const {WsRpcGroup,ORCHESTRATION_PROTOCOL_VERSION,ORCHESTRATION_PROTOCOL_HEADER} = contracts; |
|
const {PING_TIMEOUT} = await import(pathToFileURL(path.join(checkout,"packages/client-runtime/src/rpc/protocol.ts")).href); |
|
const evidence = fs.mkdtempSync(path.join(os.tmpdir(),"t3-22865-" + phase + "-")); |
|
const home = path.join(evidence,"home"); |
|
const workspace = path.join(evidence,"workspace"); |
|
fs.mkdirSync(path.join(home,"userdata"),{recursive:true}); |
|
fs.mkdirSync(workspace); |
|
execFileSync("git",["init","-q",workspace]); |
|
fs.writeFileSync(path.join(workspace,"fixture.txt"),"Issue 22865 isolated protocol fixture\n"); |
|
execFileSync("git",["-C",workspace,"add","fixture.txt"]); |
|
execFileSync("git",["-C",workspace,"-c","user.name=Verifier","-c","user.email=verifier@localhost","commit","-qm","Fixture"]); |
|
const fixture = path.join(os.tmpdir(),"slot8-22865-grok-fixture.mjs"); |
|
fs.copyFileSync(fixture,path.join(evidence,"grok-fixture.mjs")); |
|
fs.copyFileSync(import.meta.filename,path.join(evidence,"verifier.mjs")); |
|
const binary = path.join(evidence,"grok-fixture.cmd"); |
|
fs.writeFileSync(binary,'@echo off\r\n"' + process.execPath + '" "' + fixture + '" %*\r\n'); |
|
const providerInstances = Object.fromEntries(["codex","claude","cursor","grok","opencode","antigravity","kiro","pi","muse","fx"].map(driver=>[driver,{driver,enabled:false}])); |
|
providerInstances["grok-e2e"]={driver:"grok",displayName:"Issue 22865 fixture",enabled:true,config:{binaryPath:process.execPath,customModels:["grok-4.7"]},environment:[{name:"NODE_OPTIONS",value:"--import="+pathToFileURL(fixture).href}]}; |
|
fs.writeFileSync(path.join(home,"userdata","settings.json"),JSON.stringify({enableProviderUpdateChecks:false,compactIdleThreads:false,providerInstances,defaultModelSelection:{instanceId:"grok-e2e",model:"grok-4.7"}})); |
|
const granted = new Set(); |
|
const gated = new Map(); |
|
const gate = http.createServer((req,res)=>{ |
|
if (!["/root","/finish","/wake"].includes(req.url)) {res.writeHead(404).end();return;} |
|
if (granted.has(req.url)) res.end("continue"); |
|
else gated.set(req.url,res); |
|
}); |
|
await new Promise(resolve=>gate.listen(0,"127.0.0.1",resolve)); |
|
const gateOrigin = "http://127.0.0.1:" + gate.address().port; |
|
const release = route => {granted.add(route);gated.get(route)?.end("continue");gated.delete(route);}; |
|
const reserve = http.createServer(); |
|
await new Promise(resolve=>reserve.listen(0,"127.0.0.1",resolve)); |
|
const port = reserve.address().port; |
|
await new Promise(resolve=>reserve.close(resolve)); |
|
const origin = "http://127.0.0.1:" + port; |
|
const bootstrap = crypto.randomUUID(); |
|
const env={...process.env,T3CODE_HOME:home,T3_22865_EVIDENCE:evidence,T3_22865_GATE:gateOrigin,T3_22865_CHECKOUT:checkout,T3CODE_DEV_SEED:"0"}; |
|
for (const name of ["VITE_HTTP_URL","VITE_WS_URL","VITE_DEV_SERVER_URL","T3CODE_BOOTSTRAP_FD","T3CODE_DEV_AUTH_TOKEN"]) delete env[name]; |
|
const server = spawn(process.execPath,[path.join(checkout,"apps/server/src/bin.ts"),"start","--base-dir",home,"--mode","desktop","--port",String(port),"--host","127.0.0.1","--no-browser","--bootstrap-fd","3","--log-level","debug"],{cwd:checkout,env,windowsHide:true,stdio:["ignore","pipe","pipe","pipe"]}); |
|
fs.writeFileSync(path.join(evidence,"server.pid"),String(server.pid)); |
|
console.log(JSON.stringify({phase,evidence,serverPid:server.pid,origin})); |
|
server.stdio[3].end(JSON.stringify({mode:"desktop",noBrowser:true,port,t3Home:home,host:"127.0.0.1",desktopBootstrapToken:bootstrap,tailscaleServeEnabled:false,tailscaleServePort:443})); |
|
const ready=Promise.withResolvers(); |
|
let tail=""; |
|
for (const pipe of [server.stdout,server.stderr]) pipe.on("data",data=>{ |
|
const text=data.toString().replaceAll(bootstrap,"[REDACTED]"); |
|
fs.appendFileSync(path.join(evidence,"server.log"),text); |
|
tail=(tail+text).slice(-16384); |
|
if (tail.includes("startup phase: complete")) ready.resolve(); |
|
}); |
|
const closed = new Promise(resolve=>server.once("close",(code,signal)=>{ready.reject(new Error("Server exited " + code + "/" + signal + "; inspect " + evidence));resolve();})); |
|
server.once("error",ready.reject); |
|
const startupDeadline=setTimeout(()=>ready.reject(new Error("Server startup deadline; inspect " + evidence)),120000); |
|
const abort = new AbortController(); |
|
let verifierDeadline; |
|
const milestones = value => {console.log(JSON.stringify(value));fs.appendFileSync(path.join(evidence,"milestones.ndjson"),JSON.stringify(value)+"\n");}; |
|
try { |
|
await ready.promise; |
|
clearTimeout(startupDeadline); |
|
verifierDeadline=setTimeout(()=>abort.abort(new Error("E2E deadline; inspect " + evidence)),180000); |
|
milestones({event:"server-ready"}); |
|
const tokenResponse=await fetch(origin+"/oauth/token",{method:"POST",body:new URLSearchParams({grant_type:"urn:ietf:params:oauth:grant-type:token-exchange",subject_token:bootstrap,subject_token_type:"urn:t3:params:oauth:token-type:environment-bootstrap",requested_token_type:"urn:ietf:params:oauth:token-type:access_token"})}); |
|
assert.ok(tokenResponse.ok); |
|
const token=await tokenResponse.json(); |
|
const headers={Authorization:"Bearer "+token.access_token,"Content-Type":"application/json",[ORCHESTRATION_PROTOCOL_HEADER]:String(ORCHESTRATION_PROTOCOL_VERSION)}; |
|
const projectId=crypto.randomUUID(); |
|
const created=await fetch(origin+"/api/projects/mutate",{method:"POST",headers,body:JSON.stringify({type:"project.create",commandId:crypto.randomUUID(),projectId,title:"Issue 22865",workspaceRoot:workspace})}); |
|
assert.ok(created.ok,await created.text()); |
|
const ticketResponse=await fetch(origin+"/api/auth/websocket-ticket",{method:"POST",headers}); |
|
assert.ok(ticketResponse.ok); |
|
const ticket=await ticketResponse.json(); |
|
const socket=Socket.layerWebSocket(origin.replace("http:","ws:")+"/ws?orchestrationProtocol="+ORCHESTRATION_PROTOCOL_VERSION+"&wsTicket="+encodeURIComponent(ticket.ticket)).pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal)); |
|
const protocol=RpcClient.layerProtocolSocket({pingTimeout:PING_TIMEOUT}).pipe(Layer.provide(socket),Layer.provide(RpcSerialization.layerJson)); |
|
const expectedSummary=phase==="baseline" ? "Child task completed without an assistant result." : "EARLY_SUCCESS_DONE"; |
|
let parentProjection; |
|
let childProjection; |
|
let childThreadId; |
|
let acknowledged=false; |
|
const parentThreadId=crypto.randomUUID(); |
|
const program=Effect.gen(function*(){ |
|
const client=yield* RpcClient.make(WsRpcGroup); |
|
const done=yield* Deferred.make(); |
|
const checkChild=projection=>{ |
|
childProjection=projection; |
|
fs.writeFileSync(path.join(evidence,"child-projection.json"),JSON.stringify(projection,null,2)); |
|
assert.ok(!projection.runs.some(r=>r.status==="failed"),"Child run failed"); |
|
if(projection.turnItems.some(item=>item.nativeItemRef?.nativeId?.endsWith("foreground")&&item.status==="completed"))release("/finish"); |
|
const final=projection.messages.some(m=>m.role==="assistant"&&m.text==="LATE_NATIVE_ANSWER"); |
|
return acknowledged&&final&&projection.runs.length===(phase==="baseline"?3:2)&&projection.runs.every(r=>r.status==="completed"); |
|
}; |
|
const onParent=Effect.fn(function*(item){ |
|
const projection=item.kind==="snapshot"?item.projection:yield*client["orchestration.getThreadProjection"]({threadId:parentThreadId}); |
|
parentProjection=projection; |
|
fs.writeFileSync(path.join(evidence,"parent-projection.json"),JSON.stringify(projection,null,2)); |
|
assert.ok(!projection.runs.some(r=>r.status==="failed"),"Parent run failed"); |
|
const child=projection.subagents[0]?.childThreadId; |
|
if(child&&!childThreadId){ |
|
childThreadId=child; |
|
yield*client["orchestration.subscribeThread"]({threadId:child}).pipe(Stream.runForEach(Effect.fn(function*(childItem){ |
|
const current=childItem.kind==="snapshot"?childItem.projection:yield*client["orchestration.getThreadProjection"]({threadId:child}); |
|
if(checkChild(current))yield*Deferred.succeed(done,undefined); |
|
})),Effect.catchCause(cause=>Deferred.failCause(done,cause)),Effect.forkScoped); |
|
} |
|
if(projection.runs[0]?.status==="completed")release("/root"); |
|
if(!acknowledged&&projection.messages.some(m=>m.role==="assistant"&&m.text.startsWith("TASK_RESULT:"))){ |
|
const answer=projection.messages.find(m=>m.role==="assistant"&&m.text.startsWith("TASK_RESULT:")).text; |
|
assert.equal(answer,"TASK_RESULT:"+expectedSummary); |
|
assert.equal(projection.subagents[0].result,expectedSummary); |
|
acknowledged=true; |
|
milestones({event:"delegated-result",phase,summary:projection.subagents[0].result,childThreadId}); |
|
release("/wake"); |
|
} |
|
}); |
|
yield*client["orchestration.launchThread"]({commandId:crypto.randomUUID(),threadId:parentThreadId,projectId,title:"Issue 22865 parent",modelSelection:{instanceId:"grok-e2e",model:"grok-4.7"},runtimeMode:"full-access",interactionMode:"default",workspaceStrategy:{type:"root"},initialMessage:{text:"E2E_22865_PARENT",attachments:[]}}); |
|
yield*client["orchestration.subscribeThread"]({threadId:parentThreadId}).pipe(Stream.runForEach(onParent),Effect.catchCause(cause=>Deferred.failCause(done,cause)),Effect.forkScoped); |
|
yield*Deferred.await(done); |
|
}).pipe(Effect.scoped,Effect.provide(protocol)); |
|
await Effect.runPromise(program,{signal:abort.signal}); |
|
assert.ok(childProjection.messages.some(m=>m.role==="assistant"&&m.text==="EARLY_SUCCESS_DONE")); |
|
const report={phase,parentThreadId,childThreadId,summary:parentProjection.subagents[0].result,childRuns:childProjection.runs.map(r=>({ordinal:r.ordinal,status:r.status})),childAnswers:childProjection.messages.filter(m=>m.role==="assistant").map(m=>m.text)}; |
|
fs.writeFileSync(path.join(evidence,"observations.json"),JSON.stringify(report,null,2)); |
|
milestones({event:"E2E-passed",...report}); |
|
} finally { |
|
clearTimeout(startupDeadline);clearTimeout(verifierDeadline); |
|
release("/root");release("/finish");release("/wake"); |
|
gate.closeAllConnections(); |
|
await new Promise(resolve=>gate.close(resolve)); |
|
if(server.exitCode===null)server.kill("SIGINT"); |
|
await closed; |
|
milestones({event:"owned-server-stopped",pid:server.pid}); |
|
} |