@givolt/i3-composer-agent 2.3.5 → 2.3.7

package/skills/i3-ui-prototype/scripts/native-files.cjs

@@ -28,8 +28,17 @@ function write(root,relative,value) {
   try { fs.writeFileSync(tmp,typeof value==='string'?value:JSON.stringify(value,null,2)+'\n',{flag:'wx'}); fs.renameSync(tmp,file); }
   finally { if(fs.existsSync(tmp)) fs.unlinkSync(tmp); }
 }
+function withLock(root,name,work) {
+  fs.mkdirSync(root,{recursive:true,mode:0o700});const lock=inside(root,name);let acquired=false;
+  for(let attempt=0;attempt<100;attempt++) {
+    try{fs.mkdirSync(lock);acquired=true;break;}
+    catch(error){if(error.code!=='EEXIST')throw error;Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,10);}
+  }
+  assert.ok(acquired,'Concurrent native audit update; no success recorded');
+  try{return work();}finally{fs.rmdirSync(lock);}
+}
 function entries(root,files) { return Object.fromEntries([...new Set(files)].sort().map(file=>[file,hash(fs.readFileSync(inside(root,file)))])); }
 const cacheRoots = new Set(['node_modules','dist','.vite','.git','coverage',...['app','starter'].flatMap(root=>['node_modules','dist','.vite','.git','coverage'].map(name=>`${root}/${name}`))]);
 // A source/public subdirectory named "dist", or an imported .log file, is still source.
 const excluded = (relative,name) => cacheRoots.has(relative) || name==='.DS_Store' || ['app/tsconfig.tsbuildinfo','starter/tsconfig.tsbuildinfo'].includes(relative);
-module.exports={fs,path,crypto,assert,hash,json,id,inside,walk,write,entries,excluded};
+module.exports={fs,path,crypto,assert,hash,json,id,inside,walk,write,withLock,entries,excluded};

package/skills/i3-ui-prototype/scripts/native-pilot.cjs

@@ -50,5 +50,10 @@ async function main(argv=process.argv.slice(2)) {
     default: throw new Error(`Unknown operation: ${operation}`);
   }
 }
-if(require.main===module) main().then(result=>{if(result!==null){process.stdout.write(JSON.stringify(result,null,2)+'\n');if(result.status==='failed')process.exitCode=1;}}).catch(error=>{process.stderr.write(JSON.stringify({status:'failed',operation:process.argv[2]||'analyze',errors:[error.message]})+'\n');process.exitCode=1;});
+function capture(result,exitCode){
+ const args=process.argv.slice(2),at=args.indexOf('--project');let project=at>=0&&args[at+1]?path.resolve(args[at+1]):process.cwd();
+ const target=args[1];if(target&&path.isAbsolute(target)&&target.includes(path.sep+'prototypes'+path.sep))project=target.slice(0,target.indexOf(path.sep+'prototypes'+path.sep));
+ require('./ptc-callbacks.cjs').captureResult({script:__filename,argv:args,project,result,exitCode});
+}
+if(require.main===module) main().then(result=>{if(result!==null){const code=result.status==='failed'?1:0;capture(result,code);process.stdout.write(JSON.stringify(result,null,2)+'\n');process.exitCode=code;}}).catch(error=>{const result={status:'failed',operation:process.argv[2]||'analyze',errors:[error.message]};try{capture(result,1);}catch{/* The primary failure remains authoritative. */}process.stderr.write(JSON.stringify(result)+'\n');process.exitCode=1;});
 module.exports={main};

package/skills/i3-ui-prototype/scripts/native-tool-result.cjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+'use strict';
+// Capture a real read-only query result when the host's Bash callback omits stdout.
+const fs=require('node:fs'),path=require('node:path'),assert=require('node:assert/strict'),{spawnSync}=require('node:child_process');
+const J=require('./ptc-callbacks.cjs');
+function main(argv=process.argv.slice(2)){
+ const args=[...argv];assert.equal(args.shift(),'--project','Explicit query project required');const project=fs.realpathSync(args.shift());assert.equal(args.shift(),'--','Separate the executable and its arguments');
+ const executable=args.shift();assert.ok(path.isAbsolute(executable)&&fs.statSync(executable).isFile(),'Use the detected absolute local executable; this command does not install tools');
+ const run=spawnSync(executable,args,{cwd:project,encoding:'utf8',timeout:30000,maxBuffer:8*1024*1024});
+ const result={type:'execute_command_result',exitCode:run.status??1,stdout:run.stdout||'',stderr:run.stderr||'',...(run.error?{error:run.error.message}:{})};
+ J.captureResult({script:__filename,argv,project,result,exitCode:result.exitCode});return result;
+}
+module.exports={main};
+if(require.main===module)try{const result=main();process.stdout.write(JSON.stringify(result)+'\n');process.exitCode=result.exitCode;}catch(error){process.stderr.write(JSON.stringify({status:'failed',errors:[error.message]})+'\n');process.exitCode=1;}

package/skills/i3-ui-prototype/scripts/prototype-dependencies.cjs

@@ -99,5 +99,5 @@ async function main(argv = process.argv.slice(2)) {
   return operation === 'check' ? check(options) : operation==='query'?query(options):require('./optional-skill-install.cjs').install(options);
 }
 module.exports = { check, skillAt, antdvTool, query, parse, main };
-if (require.main === module) main().then(result => {process.stdout.write(JSON.stringify(result, null, 2) + '\n');if(result.status==='failed')process.exitCode=1;})
+if (require.main === module) main().then(result => {const {options}=parse(process.argv.slice(2));require('./ptc-callbacks.cjs').captureResult({script:__filename,argv:process.argv.slice(2),project:path.resolve(options.project||process.cwd()),result,exitCode:result.status==='failed'?1:0});process.stdout.write(JSON.stringify(result, null, 2) + '\n');if(result.status==='failed')process.exitCode=1;})
   .catch(error => { process.stderr.write(JSON.stringify({ status: 'failed', errors: [error.message] }) + '\n'); process.exitCode = 1; });

package/skills/i3-ui-prototype/scripts/prototype-hooks.cjs

@@ -56,8 +56,9 @@ function check(options,runtime={}) {
   const entries=runtime.entries||[];
   if(!runtime.entries&&fs.existsSync(parent))for(const name of fs.readdirSync(parent)) {
    if(!/^[a-f0-9]{24}$/.test(name))continue;
-   const raw=R.fileIO.read(path.join(parent,name,'session.json'));if(!raw)continue;
-   entries.push(...Object.values(JSON.parse(raw).bindings||{}));
+   const raw=R.fileIO.read(path.join(parent,name,'session.json'));
+   if(raw)entries.push(...Object.values(JSON.parse(raw).bindings||{}));
+   const observed=R.fileIO.read(path.join(parent,name,'observation.json'));if(observed)entries.push(JSON.parse(observed));
   }
   for(const entry of entries)if((entry.host||'codebuddy')===host&&entry.project===current.project&&entry.registrationDigest===record.registrationDigest&&entry.settingsDigest===record.settingsDigest&&(!observation||entry.lastHook.at>observation.lastHook.at))observation=entry;
   if(observation) {
@@ -68,9 +69,12 @@ function check(options,runtime={}) {
    result.observation={sessionId:observation.sessionId,projectKey:observation.projectKey,runId:observation.runId,event:observation.lastHook.event,at:observation.lastHook.at};
    const observedProduct=observation.product||(record.product!=='auto'?record.product:null);
    assert.ok(['ide','cli'].includes(observedProduct),'Observed native product identity missing');
-   Object.assign(result,{product:observedProduct,productVersion:observation.productVersion||'unreported',effective:effectiveByProduct[observedProduct]===true,identitySource:observation.identitySource||'legacy-profile',recovery:observation.recovery||null});
+   Object.assign(result,{product:observedProduct,productVersion:observation.productVersion||'unreported',effective:effectiveByProduct[observedProduct]===true,identitySource:observation.identitySource||'legacy-profile',recovery:observation.recovery||null,...(observation.callMode?{callMode:observation.callMode,skills:observation.skills}:{})});
   }
   const recent=observation&&Date.now()-Date.parse(observation.lastHook.at)>=0&&Date.now()-Date.parse(observation.lastHook.at)<30*60*1000;
+  const failure=require('./execution-diagnostics.cjs').latest({base:current.base,project:current.project,host,record});
+  if(failure&&(!observation||failure.at>=observation.lastHook.at))return {...result,status:'failed',failure,errors:[failure.reason],transcript:{...result.transcript,status:'failed',invocationVerified:false},
+   next:failure.status==='blocked'?'修复宿主或适配后，由用户发起新的继续任务；只读诊断不消耗恢复次数。':'按 failure.reason 检查当前宿主协议；最多两次补调，不能将注册状态当作执行成功。'};
   return {...result,status:result.effective&&recent?'active':record.product==='cli'?'pending-host-review':'registered',
    activationScope:'Only the displayed project/session/configuration and adapter bytes; not all projects or business acceptance',
    next:'CLI: review /hooks; desktop: reload. Verify an actual Skill invocation and missing-Skill recovery in the chosen host.'};

package/skills/i3-ui-prototype/scripts/ptc-callbacks.cjs

@@ -0,0 +1,131 @@
+'use strict';
+// Native Pre/Post callbacks are the evidence. REPL source and claimed returns are never interpreted.
+const fs=require('node:fs'),path=require('node:path'),assert=require('node:assert/strict');
+const F=require('./native-files.cjs'),E=require('./execution-evidence.cjs'),C=require('./codebuddy-context.cjs'),P=require('./execution-policy.cjs');
+const {toolName}=require('./native-tool-name.cjs');
+const canonical=x=>Array.isArray(x)?x.map(canonical):x&&typeof x==='object'?Object.fromEntries(Object.keys(x).sort().map(k=>[k,canonical(x[k])])):x;
+const digest=x=>E.sha(JSON.stringify(canonical(x)));
+const fileFor=(record,project,sessionId)=>path.join(C.sessionDirectory(record,project,sessionId),'ptc-callbacks.json');
+function load(file){
+ if(!fs.existsSync(file))return null;
+ assert.ok(!fs.lstatSync(file).isSymbolicLink()&&fs.statSync(file).size<=64*1024*1024,'Invalid PTC callback journal');return JSON.parse(fs.readFileSync(file,'utf8'));
+}
+function locked(file,work){
+ const folder=path.dirname(file);fs.mkdirSync(folder,{recursive:true,mode:0o700});const lock=file+'.lock';let acquired=false;
+ for(let n=0;n<40;n++){try{fs.mkdirSync(lock);acquired=true;break;}catch(error){if(error.code!=='EEXIST')throw error;Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,10);}}
+ assert.ok(acquired,'Concurrent native PTC callback; retry without inventing evidence');
+ try{return work();}finally{fs.rmdirSync(lock);}
+}
+function validate(store,source,{record,project,sessionId}){
+ assert.equal(store.schemaVersion,1,'Unsupported PTC callback schema');assert.equal(store.sessionId,sessionId,'PTC callback session differs');assert.equal(store.project,project,'PTC callback project differs');
+ assert.equal(store.registrationDigest,record.registrationDigest,'PTC callback registration digest changed');assert.equal(store.settingsDigest,record.settingsDigest,'PTC callback settings digest changed');
+ assert.equal(store.sourcePath,source.path,'PTC native transcript path changed');
+ assert.ok(Number.isSafeInteger(store.sequence)&&store.sequence>=0&&store.sequence<900000,'Invalid native callback sequence');
+ const sequences=new Set();
+ const sequence=value=>{assert.ok(Number.isSafeInteger(value)&&value>0&&value<=store.sequence&&!sequences.has(value),'Invalid or duplicate native callback sequence');sequences.add(value);};
+ for(const [id,item] of Object.entries(store.calls)) {
+  assert.equal(item.id,id,'Native callback call ID changed');assert.equal(item.sessionId,sessionId,'Native callback call session changed');
+  assert.equal(digest(item.pre),digest({id:item.id,name:item.name,input:item.input,sessionId:item.sessionId,parentId:item.parentId,cwd:item.cwd}),'Native callback request changed');
+  sequence(item.preSequence);
+  if(item.post){sequence(item.postSequence);assert.ok(item.postSequence>item.preSequence,'Native callback Post must follow Pre');}
+  else assert.equal(item.postSequence,undefined,'Native callback result sequence without a result');
+ }
+ for(const parent of Object.values(store.parents)){
+  const call=source.calls.find(c=>c.toolCallId===parent.toolCallId);
+  assert.ok(call?.name==='REPL'&&call.sessionId===sessionId,'Native parent REPL request missing or session differs');
+  assert.equal(call.requestDigest,parent.requestDigest,'Native parent request digest changed');assert.equal(call.requestLine,parent.requestLine,'Native parent request cursor changed');
+  assert.ok(source.prompts.some(p=>p.line===parent.promptLine&&p.digest===parent.promptDigest),'Native parent task source changed');
+ }
+}
+function read(source,{record,project,sessionId}){
+ source={...source,calls:source.calls.filter(c=>c.evidenceSource!=='native-hook-callback')};
+ const store=load(fileFor(record,project,sessionId));if(!store)return source;
+ validate(store,source,{record,project,sessionId});
+ const inner=[];
+ for(const item of Object.values(store.calls)){
+  const parent=store.parents[item.parentId];assert.ok(parent,'PTC parent callback anchor missing');
+  const name=toolName(item.name),input=item.input,skillName=name==='Skill'?input?.skill||input?.name||input?.command:null;
+  assert.ok(!source.calls.some(c=>c.toolCallId===item.id),'Duplicate native inner tool call ID');
+  const call={toolCallId:item.id,name,input,skillName:skillName||null,skill:P.skillKey(skillName),sessionId,cwd:item.cwd,contextLine:parent.contextLine,promptLine:parent.promptLine,
+   requestLine:parent.requestLine+item.preSequence/1e6,requestDigest:digest(item.pre),success:false,parentToolCallId:item.parentId,evidenceSource:'native-hook-callback'};
+  if(item.post){
+   let result=item.post.response;
+   if(item.cliResult){
+    const value=item.cliResult;assert.equal(E.sha(fs.readFileSync(value.script)),value.scriptDigest,'Captured CLI script bytes changed');
+    assert.equal(value.inputDigest,digest(item.input),'Captured CLI input differs');
+    assert.equal(item.post.response?.exitCode,value.exitCode,'Native Bash exit differs from captured CLI result');
+    result={type:'execute_command_result',stdout:typeof value.result==='string'?value.result:JSON.stringify(value.result),exitCode:value.exitCode};
+   }
+   call.result=result;call.resultLine=parent.requestLine+item.postSequence/1e6;call.resultDigest=digest({post:item.post,cliResult:item.cliResult||null});
+   call.success=!item.denied&&!result?.interrupted&&!result?.sandboxDenied&&!result?.signal&&E.successful({content:result});
+  }
+  inner.push(call);
+ }
+ return {...source,calls:[...source.calls,...inner].sort((a,b)=>a.requestLine-b.requestLine),callMode:'ptc-repl',callbackJournal:{path:fileFor(record,project,sessionId),digest:digest(store),tamperProof:false}};
+}
+function observe({payload,record,project,source}){
+ const sessionId=payload.session_id,name=toolName(payload.tool_name),id=payload.tool_use_id||payload.call_id;
+ assert.ok(sessionId&&id,'Native PTC session and tool call ID required');
+ assert.ok(!payload.agent_id&&!payload.parent_agent_id,'PTC main task cannot inherit subagent callbacks');
+ assert.ok(source.calls.every(c=>c.sessionId===sessionId),'Native PTC callback session differs');
+ const task=source.prompts.at(-1);assert.ok(task,'Native PTC user task missing');
+ const candidates=source.calls.filter(c=>c.name==='REPL'&&!c.resultLine&&c.requestLine>task.line&&c.contextLine===source.contextLine);
+ const direct=source.calls.find(c=>c.toolCallId===id);
+ if(direct&&!direct.evidenceSource&&direct.name!=='REPL')return source;
+ if(name==='REPL'&&payload.hook_event_name==='PostToolUse'&&direct?.name==='REPL')return read(source,{record,project,sessionId});
+ assert.equal(candidates.length,1,'Native PTC callback requires a unique pending parent REPL');
+ const parent=candidates[0],file=fileFor(record,project,sessionId);
+ locked(file,()=>{
+  const store=load(file)||{schemaVersion:1,sessionId,project,sourcePath:source.path,registrationDigest:record.registrationDigest,settingsDigest:record.settingsDigest,sequence:0,parents:{},calls:{}};
+  validate(store,source,{record,project,sessionId});
+  const next=()=>{assert.ok(++store.sequence<900000,'Native PTC callback journal limit reached');return store.sequence;};
+  if(name==='REPL'){
+   assert.equal(id,parent.toolCallId,'Native outer REPL call differs');assert.equal(digest(payload.tool_input||{}),digest(parent.input),'Native outer REPL input differs');
+   if(payload.hook_event_name==='PreToolUse')store.parents[id]||={toolCallId:id,requestDigest:parent.requestDigest,requestLine:parent.requestLine,promptLine:task.line,promptDigest:task.digest,contextLine:source.contextLine};
+  }else{
+   assert.ok(store.parents[parent.toolCallId],'Native parent PreToolUse callback missing');
+   const input=payload.tool_input||{},pre={id,name,input,sessionId,parentId:parent.toolCallId,cwd:payload.cwd};
+   if(payload.hook_event_name==='PreToolUse'){
+    if(store.calls[id])assert.equal(digest(store.calls[id].pre),digest(pre),'Conflicting native PTC call input or parent changed');
+    else store.calls[id]={...pre,pre,preSequence:next()};
+   }else if(payload.hook_event_name==='PostToolUse'){
+    const item=store.calls[id];assert.ok(item,'Paired native PTC PreToolUse request missing');assert.equal(digest(item.pre),digest(pre),'Native PTC Post input differs');
+    assert.ok(Object.hasOwn(payload,'tool_response'),'Native PTC Post response missing');const post={response:payload.tool_response};
+    if(item.post)assert.equal(digest(item.post),digest(post),'Conflicting native PTC Post result changed');
+    else {item.post=post;item.postSequence=next();}
+   }
+  }
+  F.write(path.dirname(file),path.basename(file),store);fs.chmodSync(file,0o600);
+ });
+ return read(source,{record,project,sessionId});
+}
+function captureResult({script,argv,project=process.cwd(),result,exitCode}){
+ // Only an actually running first-party entry may capture stdout. Match its exact pending native command.
+ const candidates=[path.join(project,'.codebuddy')];let folder=path.dirname(script);
+ for(let n=0;n<5;n++,folder=path.dirname(folder))candidates.push(folder);
+ const global=C.globalBase();candidates.push(global);
+ const matches=[];
+ for(const base of [...new Set(candidates)]){
+  if(!fs.existsSync(path.join(base,'state/i3-prototype/installation.json')))continue;
+  const record=C.registration(base),parent=path.join(base,'state/i3-prototype',C.projectKey(project));if(!fs.existsSync(parent))continue;
+  for(const session of fs.readdirSync(parent)){
+   if(!/^[a-f0-9]{24}$/.test(session))continue;const file=path.join(parent,session,'ptc-callbacks.json'),store=load(file);if(!store)continue;
+   if(store.registrationDigest!==record.registrationDigest||store.project!==project)continue;
+   for(const item of Object.values(store.calls)){
+    if(item.name!=='Bash'||item.post||item.cliResult)continue;
+    const tokens=require('./native-command.cjs').tokens(item.input?.command);
+    if(!tokens||tokens.length!==argv.length+2||digest(tokens.slice(2))!==digest(argv))continue;
+    const cwd=item.cwd||project,real=file=>{try{return fs.realpathSync(file);}catch{return null;}};
+    const executable=tokens[0].includes(path.sep)?path.resolve(cwd,tokens[0]):(process.env.PATH||'').split(path.delimiter).map(dir=>path.resolve(cwd,dir,tokens[0])).find(file=>{try{fs.accessSync(file,fs.constants.X_OK);return fs.statSync(file).isFile();}catch{return false;}});
+    if(executable&&real(executable)===real(process.execPath)&&real(path.resolve(cwd,tokens[1]))===real(script))matches.push({file,item});
+   }
+  }
+ }
+ if(!matches.length)return false;assert.equal(matches.length,1,'Captured CLI result has multiple pending native requests');
+ const {file,item}=matches[0];locked(file,()=>{
+  const store=load(file),current=store.calls[item.id];assert.ok(current&&!current.post&&!current.cliResult,'Captured CLI callback changed');
+  current.cliResult={script,scriptDigest:E.sha(fs.readFileSync(script)),argv,inputDigest:digest(current.input),result,exitCode,at:new Date().toISOString()};
+  F.write(path.dirname(file),path.basename(file),store);
+ });return true;
+}
+module.exports={observe,read,captureResult};