afucontext 0.0.0-stage → 0.1.18

package/bin/afu.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/** No postinstall side effects; recover only our versioned runtime cache. */
+import {spawn,spawnSync} from 'node:child_process';
+import {readFileSync,readdirSync} from 'node:fs';
+import {dirname,join,resolve} from 'node:path';
+import {homedir,constants} from 'node:os';
+import {fileURLToPath} from 'node:url';
+import {guide,hostCommand} from './install-guide.mjs';
+import {prepareRuntime} from './runtime.mjs';
+import {holdCache} from './cache-lease.mjs';
+import {preparePlatform} from './platform.mjs';
+const root=resolve(dirname(fileURLToPath(import.meta.url)),'..');
+const manifest=JSON.parse(readFileSync(join(root,'release.json'),'utf8'));
+const env={...process.env,AFU_INSTALL_ROOT:root};
+let args=process.argv.slice(2);
+if(['install','upgrade','status','remove','gc','native','repair'].includes(args[0])){
+ const at=args.indexOf('--state');if(at>=0&&args[at+1])env.AFU_STATE_DIR=resolve(args[at+1]);
+ const inline=args.find(a=>a.startsWith('--state='));if(inline&&inline.length>8)env.AFU_STATE_DIR=resolve(inline.slice(8));
+}
+let release;
+// Ctrl-C already reaches the child through the shared foreground process group;
+// relaying SIGINT again would deliver it twice. Only forward signals sent to
+// this launcher alone, and only to our own child.
+function relaySignals(child){
+  process.on('SIGINT',()=>{});
+  for(const signal of ['SIGTERM','SIGHUP'])process.on(signal,()=>child.kill(signal));
+}
+function exitCode(code,signal){
+  if(code!==null&&code!==undefined)return code;
+  return signal&&constants.signals[signal]?128+constants.signals[signal]:1;
+}
+/** Installed integrations, with what each upgrade needs (config dir, host home, profile). */
+function installedHosts(state){
+  const read=f=>{try{return JSON.parse(readFileSync(f,'utf8'));}catch{return null;}};
+  const found=[];let names=[];
+  try{names=readdirSync(join(state,'integrations')).filter(n=>n.endsWith('.json'));}catch{return found;}
+  for(const name of names){
+    const record=read(join(state,'integrations',name));
+    if(!record)continue;
+    if(typeof record.location==='string'&&!/[\\/]/.test(record.location)){
+      const receipt=read(join(state,'native',record.location,'install.json'));
+      if(receipt&&!receipt.removed&&['claude','codex'].includes(receipt.host))
+        found.push({host:receipt.host,version:receipt.version,args:receipt.directory?['--config-dir',receipt.directory]:[],env:{}});
+    }else if(['pi','dsh'].includes(record.host)&&!record.removed){
+      if(record.plugin_runtime)found.push({host:'dsh',version:record.version,args:['--runtime-only'],env:{}});
+      for(const [key,entry] of Object.entries(record.autoload||{})){
+        if(record.host==='pi'){
+          const agent=entry.entry?dirname(dirname(entry.entry)):null;
+          found.push({host:'pi',version:record.version,args:[],env:agent?{PI_CODING_AGENT_DIR:agent}:{}});
+        }else{
+          const home=entry.manifest?dirname(dirname(dirname(entry.manifest))):null;
+          found.push({host:'dsh',version:record.version,args:['--profile',key],env:home?{DSH_HOME:home}:{}});
+        }
+      }
+    }
+  }
+  return found;
+}
+/** Upgrade every installed host to this launcher's version, one after another. */
+function updateAll(extra){
+  const at=extra.indexOf('--state');
+  const state=at>=0&&extra[at+1]?resolve(extra[at+1]):(env.AFU_STATE_DIR||join(homedir(),'.local/share/afu-context'));
+  const hosts=installedHosts(state);
+  if(!hosts.length){console.error('AFU: nothing installed to update; run install HOST first');return 1;}
+  let failed=0;
+  for(const item of hosts){
+    const label=item.host+(item.args[0]==='--profile'?` (profile ${item.args[1]})`:item.args[0]==='--runtime-only'?' (dsh plugin runtime)':'');
+    console.error(`AFU: updating ${label}: ${item.version||'unknown'} -> ${manifest.version}`);
+    // COSEC: this launcher's own script, argv array, no shell.
+    const run=spawnSync(process.execPath,[fileURLToPath(import.meta.url),'upgrade',item.host,...item.args,...extra],{stdio:'inherit',env:{...env,...item.env}});
+    if(run.status!==0){failed++;console.error(`AFU: update of ${label} failed; it keeps its current version`);}
+  }
+  console.error(failed?`AFU: ${hosts.length-failed} of ${hosts.length} updated to ${manifest.version}`:`AFU: all ${hosts.length} integrations are on ${manifest.version}. Open new host sessions to use it.`);
+  return failed?1:0;
+}
+try{
+  // Only the bare launcher prints its own banner; "afu ui --help" and
+  // "afu claude --help" belong to the subcommand or the host.
+  if(!args.length || (['--help','-h'].includes(args[0]))){
+    const pkg=manifest.name||'afucontext',npx=`npx --yes --registry=https://registry.npmjs.org ${pkg}@latest`;
+    console.log(`afuctx ${manifest.version}: AFU Context, local context compression for coding agents\n\n  ${npx} install [claude|codex|pi|dsh]\n  ${npx} update            upgrade every installed host\n  ${npx} remove HOST\n  ${npx} status [HOST]\n  ${npx} dashboard         open the local dashboard\n  ${npx} gc --dry-run\n  ${npx} --version\n\nAfter installing, the same commands are on PATH as afuctx (status, dashboard, --help, --version) and afuctx-admin (dashboard). Host login remains managed by the host.`);
+    process.exit(0);
+  }
+  if(['--version','-v','version'].includes(args[0])){console.log(manifest.version);process.exit(0);}
+  if(args[0]==='update'){process.exitCode=updateAll(args.slice(1));process.exit();}
+  if(['dashboard','admin'].includes(args[0]))args=['ui',...args.slice(1)];
+  args=await guide(args,env);
+  if(['install','upgrade'].includes(args[0])&&args.includes('--dry-run')){
+    console.log(JSON.stringify({preflight:'passed',host:args[1],configuration_changed:false,request_observed:false}));process.exit(0);
+  }
+  let removed=false;
+  if(['pi','dsh'].includes(args[0])){
+    const receipt=join(env.AFU_STATE_DIR??join(homedir(),'.local/share/afu-context'),'integrations',args[0]+'.json');
+    try{removed=JSON.parse(readFileSync(receipt,'utf8')).removed===true;}catch(e){if(e.code!=='ENOENT')throw Error('INVALID_INSTALLATION_RECORD');}
+  }
+  if(removed){
+    const split=args.indexOf('--');
+    if(split<0 && args.length>1)throw Error('PLUGIN_REMOVED: pass host arguments after --');
+    // COSEC: fixed host executable, argv array, no shell; no runtime downloads.
+    const [binary,...prefix]=hostCommand(args[0],env);
+    const child=spawn(binary,[...prefix,...(split<0?[]:args.slice(split+1))],{stdio:'inherit',env,shell:false});
+    relaySignals(child);
+    child.on('error',()=>{console.error('AFU: HOST_EXECUTABLE_UNAVAILABLE');process.exitCode=1;});
+    child.on('exit',(code,signal)=>{process.exitCode=exitCode(code,signal);});
+  }else{
+  const hostAction = ['pi','dsh'].includes(args[1]) && ['install','upgrade','remove','status'].includes(args[0]);
+  // Status always goes through one reporter (it understands autoload receipts,
+  // --json and --state); only Pi/DSH install/upgrade/remove need host-autoload.
+  const directHost = hostAction && args[0]!=='status';
+  if (directHost && ['install','upgrade'].includes(args[0])) {
+    // Autoload paths must outlive npx eviction and the ordinary launcher cache GC.
+    const state = env.AFU_STATE_DIR || join(homedir(), '.local/share/afu-context');
+    env.AFU_RUNTIME_DIR = join(state, 'autoload', 'runtimes');
+  }
+  env.AFU_NODE = process.execPath;
+  if (args[0] === 'pi') env.AFU_EXPLICIT_EXTENSION = 'pi';
+  release=await holdCache(manifest.build,env);
+  const location=await prepareRuntime(root,manifest,env);
+  const python=join(location,process.platform==='win32'?'Scripts/python.exe':'bin/python');
+  env.AFU_INSTALL_ROOT=await preparePlatform(root,manifest,args,env);
+  const entry = directHost ? [join(root,'bin/host-autoload.py')] : ['-m','afu_context.local_cli'];
+  const child=spawn(python,[...entry,...args],{stdio:'inherit',env});
+  relaySignals(child);
+  child.on('error',()=>{release?.();console.error('AFU failed to start');process.exitCode=1;});
+  child.on('exit',(code,signal)=>{release?.();if(code===0&&['install','upgrade'].includes(args[0]))console.error(`AFU: installed ${args[1]} ${manifest.version}; ${['claude','codex'].includes(args[1])?'service checked; open a new '+args[1]+' session':directHost?'open a new host session':'launch with afu '+args[1]}. Waiting for the first observed request; compression is not yet verified.`);process.exitCode=exitCode(code,signal);});
+  }
+}catch(error){release?.();console.error('AFU: '+error.message);process.exitCode=1;}

package/bin/cache-lease.mjs

@@ -0,0 +1,16 @@
+import {mkdirSync,writeFileSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {homedir} from 'node:os';
+import {randomUUID,createHash} from 'node:crypto';
+import {recoverLock} from './runtime.mjs';
+export async function holdCache(build,env=process.env){
+ if(!/^[a-f0-9]{64}$/.test(build))throw Error('Invalid build identity');
+ const base=env.AFU_RUNTIME_DIR??join(homedir(),'.local/share/afu-context/runtimes');
+ mkdirSync(base,{recursive:true,mode:0o700});
+ const guard=join(base,'.gc-lock');const end=Date.now()+10000;
+ while(true){try{mkdirSync(guard);writeFileSync(join(guard,'owner.json'),JSON.stringify({pid:process.pid}));break;}catch(e){if(e.code!=='EEXIST')throw e;recoverLock(guard);if(Date.now()>end)throw Error('CACHE_GC_BUSY');await new Promise(r=>setTimeout(r,50));}}
+ const file=join(base,'.clients',randomUUID()+'.json');
+ const state=env.AFU_STATE_DIR??join(homedir(),'.local/share/afu-context');
+ try{mkdirSync(join(base,'.owners'),{recursive:true,mode:0o700});writeFileSync(join(base,'.owners',createHash('sha256').update(state).digest('hex')+'.json'),JSON.stringify({state}),{mode:0o600});mkdirSync(join(base,'.clients'),{recursive:true,mode:0o700});writeFileSync(file,JSON.stringify({pid:process.pid,build}),{mode:0o600});}finally{rmSync(guard,{recursive:true,force:true});}
+ const release=()=>rmSync(file,{force:true});process.once('exit',release);return release;
+}