@caveman-ai/cloud 0.0.1 → 0.1.0-rc.22

package/bin/cvm.mjs

@@ -1,19 +1,24 @@
 #!/usr/bin/env node
-// cvm, the Caveman Cloud CLI. `caveman login` owns sign-in: cvm reads the
-// credential it saved (~/.caveman-cloud/config.json points at the macOS
-// Keychain item or the 0600 credentials file) and writes a refreshed one back
-// to the same place, so neither CLI ever signs the other out.
-import {readFileSync,writeFileSync,mkdirSync,chmodSync,renameSync,existsSync,realpathSync} from 'node:fs';
-import {execFileSync,spawnSync} from 'node:child_process';
+// cvm, the Caveman Cloud CLI. It signs in with the browser device flow and
+// stores the credential exactly where `caveman login` does
+// (~/.caveman-cloud/config.json points at the macOS Keychain item or the 0600
+// credentials file), so either CLI's sign-in serves both, and a refreshed pair
+// goes back to the same place, so neither CLI ever signs the other out.
+import {readFileSync,writeFileSync,mkdirSync,chmodSync,renameSync,existsSync,realpathSync,cpSync,rmSync,readdirSync,statSync} from 'node:fs';
+import {execFileSync,spawn} from 'node:child_process';
 import {randomUUID} from 'node:crypto';
 import {homedir} from 'node:os';
 import {join,dirname,delimiter} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {parseArgs} from 'node:util';
+import {setTimeout as pause} from 'node:timers/promises';
 
-const win=process.platform==='win32';
-const cmdQuote=arg=>`"${String(arg).replaceAll('"','""')}"`;
+const version=JSON.parse(readFileSync(new URL('../package.json',import.meta.url),'utf8')).version;
+const client=()=>import('../dist/cloud-client.mjs');
 const configPath=join(homedir(),'.caveman-cloud','config.json');
 const credentialsPath=join(process.env.CAVEMAN_HOME??join(homedir(),'.caveman'),'credentials');
 const keychain=['-s','caveman','-a','token'];
+const origin=url=>(url??'').replace(/\/+$/,'');
 
 function readConfig(){try{return JSON.parse(readFileSync(configPath,'utf8'));}catch{return {};}}
 function writePrivate(path,text){
@@ -30,7 +35,8 @@ function storedSecret(meta){
 }
 // A stored secret is the credentials JSON, or a bare access token in older stores.
 function decode(raw){try{const parsed=JSON.parse(raw);if(typeof parsed.access_token==='string')return parsed;}catch{}return {access_token:raw};}
-function expiresSoon(token){try{return JSON.parse(Buffer.from(token.split('.')[0],'base64url').toString('utf8')).exp<=Date.now()/1000+60;}catch{return false;}}
+const claims=token=>{try{return JSON.parse(Buffer.from(token.split('.')[0],'base64url').toString('utf8'))??{};}catch{return {};}};
+const expiresSoon=token=>claims(token).exp<=Date.now()/1000+60;
 function store(credentials){
  const secret=JSON.stringify(credentials);
  if(process.platform==='darwin'&&!process.env.CAVE_NO_KEYCHAIN){try{execFileSync('security',['add-generic-password','-U',...keychain,'-w',secret],{stdio:'ignore'});return 'keychain';}catch{}}
@@ -58,34 +64,262 @@ async function refresh(meta,credentials,baseURL){
  }catch{return credentials;}
 }
 async function context(){
- const meta=readConfig(),baseURL=meta.baseURL||process.env.CAVE_API_URL||'https://api.caveman.so'; // logout leaves baseURL empty
- if(process.env.CAVE_TOKEN)return {baseURL,token:process.env.CAVE_TOKEN,projectId:meta.projectId};
+ // The environment wins over the saved login, and a flag over both (--project,
+ // read by the client). logout leaves baseURL empty.
+ const meta=readConfig(),baseURL=process.env.CAVE_API_URL||meta.baseURL||'https://api.caveman.so';
+ const projectId=process.env.CAVE_PROJECT_ID||meta.projectId;
+ if(process.env.CAVE_TOKEN)return {baseURL,token:process.env.CAVE_TOKEN,projectId};
+ // The saved credential was issued by the saved address and is sent nowhere
+ // else: another CAVE_API_URL needs its own CAVE_TOKEN.
+ if(meta.baseURL&&origin(baseURL)!==origin(meta.baseURL))return {baseURL,token:undefined,projectId};
  let credentials=decode(storedSecret(meta));
  if(!meta.logoutPendingLocalCleanup&&credentials.refresh_token&&expiresSoon(credentials.access_token))credentials=await refresh(meta,credentials,baseURL);
- return {baseURL,token:credentials.access_token,projectId:meta.projectId??credentials.project_id};
-}
-// Sign-in stays in caveman: run the installed one, or fetch it once with npx.
-function login(args){
- const installed=(process.env.PATH??'').split(delimiter).some(dir=>dir&&existsSync(join(dir,win?'caveman.cmd':'caveman')));
- const [command,prefix]=installed?['caveman',['login']]:['npx',['-y','@caveman-ai/cli@latest','login']];
- // Windows runs the .cmd shim through cmd.exe with every argument quoted.
- const result=win
-  ?spawnSync(process.env.ComSpec??'cmd.exe',['/d','/s','/c',`"${[command,...prefix,...args].map(cmdQuote).join(' ')}"`],{stdio:'inherit',windowsVerbatimArguments:true})
-  :spawnSync(command,[...prefix,...args],{stdio:'inherit'});
- if(result.status!==0)process.exit(result.status??1);
+ return {baseURL,token:credentials.access_token,projectId:projectId??credentials.project_id};
+}
+const post=(url,body,headers={})=>fetch(url,{method:'POST',redirect:'error',headers:{'content-type':'application/json','x-cave-client':'cli',...headers},body:JSON.stringify(body),signal:AbortSignal.timeout(10000)});
+function openBrowser(url){
+ const [command,args]=process.platform==='darwin'?['open',[url]]:process.platform==='win32'?['rundll32.exe',['url.dll,FileProtocolHandler',url]]:['xdg-open',[url]];
+ try{spawn(command,args,{detached:true,stdio:'ignore'}).on('error',()=>{}).unref();}catch{}
+}
+// RFC 8628 device grant: the requests `caveman login` makes, and the
+// credential stored where it stores one.
+async function login(args=[]){
+ const {CloudError}=await client();
+ let values;try{({values}=parseArgs({args,strict:true,options:{instance:{type:'string'},'no-browser':{type:'boolean'}}}));}catch{throw new CloudError('cave_usage','Use cvm login [--instance URL] [--no-browser].',2);}
+ const baseURL=origin(values.instance||process.env.CAVE_API_URL||readConfig().baseURL||'https://api.caveman.so');
+ let url;try{url=new URL(baseURL);}catch{}
+ if(!url||url.username||url.password||url.pathname!=='/'||url.search||url.hash||url.protocol!=='https:'&&!(url.protocol==='http:'&&['localhost','127.0.0.1','[::1]'].includes(url.hostname)))throw new CloudError('cave_endpoint_invalid','Sign in over HTTPS (plain HTTP only on localhost), to an origin with no path, credentials, query or fragment.',2);
+ const started=await post(`${baseURL}/api/v1/auth/device/code`,{}).catch(()=>{throw new CloudError('cave_network_error',`Could not reach ${baseURL}.`,1);});
+ const code=await started.json().catch(()=>({}));
+ if(started.status===403&&code.error?.code==='cave_device_login_disabled')throw new CloudError('cave_device_login_disabled','Device login is not open on this installation.',3);
+ if(!started.ok||typeof code.device_code!=='string')throw new CloudError(code.error?.code??'cave_device_login_failed',`Could not start sign-in at ${baseURL} (HTTP ${started.status}).`,1);
+ const link=code.verification_uri_complete??code.verification_uri;
+ process.stderr.write(`Confirm the code ${code.user_code} in your browser: ${link}\n`);
+ if(!values['no-browser']&&!process.env.CAVE_NO_BROWSER&&/^https?:\/\//.test(link))openBrowser(link);
+ let interval=Number(code.interval??5)*1000;const deadline=Date.now()+Number(code.expires_in??600)*1000;
+ const expired=new CloudError('expired_token','The code expired before it was confirmed. Run cvm login again.',3);
+ while(Date.now()<deadline){
+  await pause(Math.max(interval,200));
+  let response,grant;
+  // A dropped poll, a rate limit or a busy server is retried until the code expires.
+  try{response=await post(`${baseURL}/api/v1/auth/device/token`,{device_code:code.device_code});if(response.status>=500||response.status===429)continue;grant=await response.json();}catch{continue;}
+  if(grant.error==='slow_down'){interval+=5000;continue;}
+  if(grant.error==='authorization_pending')continue;
+  if(grant.error==='expired_token')throw expired;
+  if(grant.error==='access_denied')throw new CloudError('access_denied','Sign-in was denied in the browser.',3);
+  if(typeof grant.access_token!=='string'||!grant.access_token)throw new CloudError(typeof grant.error==='string'?grant.error:'cave_device_login_failed',`Sign-in failed: ${typeof grant.error==='string'?grant.error:`HTTP ${response.status}`}.`,1);
+  const credentials=Object.fromEntries(['access_token','refresh_token','gateway_api_key','gateway_key_id','project_id'].filter(key=>typeof grant[key]==='string'&&grant[key]).map(key=>[key,grant[key]]));
+  const tokenStore=store(credentials),{oid}=claims(credentials.access_token);
+  // No gatewayUrl: with one, `caveman enable claude` switches to managed mode
+  // and writes a gateway base URL with no key into Claude Code's settings.
+  const {token,logoutPendingLocalCleanup,gatewayUrl,organizationId,projectId,...rest}=readConfig();
+  writePrivate(configPath,JSON.stringify({...rest,baseURL,tokenStore,...(typeof oid==='string'?{organizationId:oid}:{}),...(credentials.project_id?{projectId:credentials.project_id}:{})},null,2)+'\n');
+  // The receipt: the server replays a durable grant until told it was stored,
+  // and may revoke one that never is.
+  if(Object.keys(credentials).length>1){
+   for(let attempt=0;;attempt++){
+    const ack=typeof grant.delivery_ack_token==='string'&&await post(`${baseURL}/api/v1/auth/device/ack`,{device_code:code.device_code,ack_token:grant.delivery_ack_token},{authorization:`Bearer ${credentials.access_token}`}).catch(()=>undefined);
+    if(ack?.ok)break;
+    if(attempt===4||ack===false||ack&&ack.status<500&&ack.status!==429)throw new CloudError('cave_device_ack_failed','Signed in, but the server did not confirm this device stored the credential and may revoke it. Run cvm login again.',1);
+    await pause(200*2**attempt);
+   }
+  }
+  return {baseURL,projectId:credentials.project_id??null};
+ }
+ throw expired;
+}
+async function loginCommand(args){
+ const {baseURL,projectId}=await login(args);
+ if(process.stdout.isTTY)process.stdout.write(`Signed in to ${baseURL}.\n`);
+ else{process.stderr.write(`Signed in to ${baseURL}.\n`);process.stdout.write(JSON.stringify({signed_in:true,api:baseURL,project_id:projectId})+'\n');}
+ return 0;
+}
+// `caveman logout`'s steps: revoke the device's gateway key and the session,
+// then forget the credential and the address.
+async function logout(){
+ const meta=readConfig(),baseURL=origin(meta.baseURL);
+ let credentials=decode(storedSecret(meta));
+ if(credentials.access_token&&baseURL&&!meta.logoutPendingLocalCleanup){
+  const {CloudError}=await client();
+  if(credentials.refresh_token&&expiresSoon(credentials.access_token))credentials=await refresh(meta,credentials,baseURL);
+  const kept=new CloudError('cave_logout_failed','Could not revoke this sign-in on the server; you are still signed in. Run cvm logout again.',1);
+  const revoke=(path,body,headers)=>post(baseURL+path,body,{authorization:`Bearer ${credentials.access_token}`,...headers}).catch(()=>{throw kept;});
+  const project=meta.projectId??credentials.project_id;
+  // The gateway key is gone only when the server says so (404 cave_key_not_found):
+  // after any other answer this is the last copy of a live key, so it stays.
+  if(project&&credentials.gateway_key_id){
+   const response=await revoke(`/api/v1/projects/${encodeURIComponent(project)}/keys/${encodeURIComponent(credentials.gateway_key_id)}/revoke`,{},{'x-cave-csrf':'cli'});
+   if(!response.ok&&!(response.status===404&&(await response.json().catch(()=>({}))).error?.code==='cave_key_not_found'))throw kept;
+  }
+  const response=await revoke('/api/v1/auth/logout',credentials.refresh_token?{refresh_token:credentials.refresh_token}:{});
+  if(!response.ok&&response.status!==401)throw kept; // 401: the session already ended
+ }
+ // Remote revocation is recorded before the only local credential goes, so a
+ // failed cleanup is retried without presenting a revoked session.
+ writePrivate(configPath,JSON.stringify({...meta,logoutPendingLocalCleanup:true},null,2)+'\n');
+ if(meta.tokenStore==='keychain'||!meta.tokenStore&&process.platform==='darwin'&&!process.env.CAVE_NO_KEYCHAIN){
+  try{execFileSync('security',['delete-generic-password',...keychain],{stdio:'ignore'});}catch(error){if(error.status!==44)throw new Error('Could not remove the credential from the macOS Keychain.');} // 44: no such item
+ }
+ if(meta.tokenStore!=='keychain')rmSync(credentialsPath,{force:true});
+ const {token,tokenStore,projectId,organizationId,gatewayUrl,logoutPendingLocalCleanup,...rest}=meta;
+ writePrivate(configPath,JSON.stringify({...rest,baseURL:''},null,2)+'\n');
+ process.stdout.write(process.stdout.isTTY?'Signed out.\n':JSON.stringify({logged_out:true})+'\n');
+ return 0;
+}
+
+// The Caveman Cloud skill, built from public/skills into this package. Claude
+// Code reads its own skills directory; Codex and Cursor read the open Agent
+// Skills one.
+const skillDirs={claude:join(process.env.CLAUDE_CONFIG_DIR||join(homedir(),'.claude'),'skills','caveman-cloud'),agents:join(homedir(),'.agents','skills','caveman-cloud')};
+const marker='.cvm-version',labels={claude:'Claude Code',codex:'Codex',cursor:'Cursor'};
+// One cvm at a time changes a skills directory, and first clears what an
+// interrupted one left. A lock over a minute old is a crashed cvm's (two cvms
+// taking over the same stale lock at one moment can both go ahead).
+function locked(dir,work){
+ const parent=dirname(dir),lock=join(parent,'.caveman-cloud.lock'),busy='another cvm is installing it';
+ try{mkdirSync(lock);}catch(error){
+  if(error.code!=='EEXIST')throw error;
+  if(Date.now()-statSync(lock).mtimeMs<60000)return busy;
+  rmSync(lock,{recursive:true,force:true});
+  try{mkdirSync(lock);}catch{return busy;}
+ }
+ try{
+  for(const name of readdirSync(parent))if(name.startsWith('.caveman-cloud-'))rmSync(join(parent,name),{recursive:true,force:true});
+  return work();
+ }finally{rmSync(lock,{recursive:true,force:true});}
+}
+// Only a directory cvm wrote (its marker says so) is replaced, by renames: an
+// agent reading it finds the old skill or the new one, never half of either.
+function installSkill(dir){
+ mkdirSync(dirname(dir),{recursive:true});
+ return locked(dir,()=>{
+  if(existsSync(dir)&&!existsSync(join(dir,marker)))return 'it holds a caveman-cloud skill cvm did not install';
+  const next=join(dirname(dir),`.caveman-cloud-${randomUUID()}`),old=next+'-old';
+  try{
+   cpSync(fileURLToPath(new URL('../dist/skills/caveman-cloud',import.meta.url)),next,{recursive:true});writeFileSync(join(next,marker),version);
+   if(existsSync(dir))renameSync(dir,old);
+   renameSync(next,dir);
+  }catch(error){
+   rmSync(next,{recursive:true,force:true});
+   if(!existsSync(dir)&&existsSync(old))renameSync(old,dir);
+   throw error;
+  }
+  rmSync(old,{recursive:true,force:true});
+ });
+}
+// Runs a client command for its JSON answer, the client's own printing held back.
+async function call(...args){
+ const {runCloudCLI}=await client();
+ let out='';const write=process.stdout.write;process.stdout.write=chunk=>(out+=chunk,true);
+ try{const code=await runCloudCLI([...args,'--format','json'],{context,login:loginCommand});return {...JSON.parse(out),code};}
+ finally{process.stdout.write=write;}
+}
+// What the onboarding screen shows of the repository, each only when git
+// answers it in a form the server accepts.
+function repository(){
+ const git=(...args)=>{try{return execFileSync('git',args,{encoding:'utf8',stdio:['ignore','pipe','ignore'],timeout:5000}).trim();}catch{return '';}};
+ const [,owner,name]=git('remote','get-url','origin').match(/([^/:]+)\/([^/]+?)(?:\.git)?\/?$/)??[];
+ const facts={repo_owner:owner,repo_name:name,default_branch:git('symbolic-ref','--short','refs/remotes/origin/HEAD').replace(/^origin\//,'')||git('branch','--show-current'),head_sha:git('rev-parse','HEAD')};
+ const valid={repo_owner:/^[A-Za-z0-9._-]{1,100}$/,repo_name:/^[A-Za-z0-9._-]{1,100}$/,default_branch:/^(?!-)(?!.*\.\.)[^\s~^:?*[\\\x00-\x1f\x7f]{1,255}$/,head_sha:/^[0-9a-f]{7,64}$/};
+ return Object.entries(facts).filter(([key,value])=>value&&valid[key].test(value));
+}
+async function setup(args){
+ const {CloudError}=await client();
+ const usage='Use cvm setup [--project UUID] [--agent claude|codex|cursor] [--remove] [--format json|table].';
+ let values;try{({values}=parseArgs({args,strict:true,options:{project:{type:'string'},agent:{type:'string'},remove:{type:'boolean'},format:{type:'string'}}}));}catch{throw new CloudError('cave_usage',usage,2);}
+ const json=(values.format??(process.stdout.isTTY?'table':'json'))==='json';
+ if(values.format&&!['json','table'].includes(values.format)||values.agent&&!labels[values.agent])throw new CloudError('cave_usage',usage,2);
+ const plain=text=>String(text).replace(/[\x00-\x1f\x7f-\x9f\p{Cf}\u2028\u2029]/gu,' ');
+ const out=(value,lines)=>process.stdout.write((json?JSON.stringify(value):lines.join('\n'))+'\n');
+ const failed=({code,...result})=>(process.stdout.write(JSON.stringify(result)+'\n'),code);
+ if(values.remove){
+  const removed=Object.values(skillDirs).filter(dir=>existsSync(dirname(dir))&&locked(dir,()=>existsSync(join(dir,marker))&&(rmSync(dir,{recursive:true,force:true}),true))===true);
+  out({skill:{removed}},[...removed.map(dir=>`Removed ${dir}`),...removed.length?[]:['No Caveman Cloud skill installed by cvm.'],'cvm logout signs you out.']);
+  return 0;
+ }
+ // 1. A credential that answers, or a sign-in.
+ let me=await call('auth','status');
+ if(me.code===3&&!process.env.CAVE_TOKEN){await login();me=await call('auth','status');}
+ if(me.code)return failed(me);
+ // 2. The project, resolved as every cvm command resolves it, saved the way
+ // `cvm context set` saves it.
+ const shown=await call('context','show',...(values.project?['--project',values.project]:[]));
+ if(shown.code)return failed(shown);
+ let project;
+ if(shown.project_id){const got=await call('projects','get',shown.project_id);if(got.code)return failed(got);project=got.data;}
+ else{
+  const list=await call('projects','list');if(list.code)return failed(list);
+  const projects=(list.data.data??[]).map(({id,name})=>({id,name}));
+  if(projects.length!==1){
+   out({schema_version:1,ok:false,status:'failed',error:{code:'cave_project_required',message:`This sign-in reaches ${projects.length} projects: pass --project UUID.`},projects},[`This sign-in reaches ${projects.length} projects: pass --project UUID.`,...projects.map(p=>`  ${p.id}  ${plain(p.name)}`)]);
+   return 2;
+  }
+  project=projects[0];
+ }
+ const saved=await call('context','set',project.id);if(saved.code)return failed(saved);
+ // 3. The skill, for the agent named, or for every agent found here.
+ const has=name=>(process.env.PATH??'').split(delimiter).some(dir=>dir&&['','.cmd','.exe'].some(ext=>existsSync(join(dir,name+ext))));
+ const found=values.agent?[values.agent]:[['claude',dirname(dirname(skillDirs.claude))],['codex',join(homedir(),'.codex')],['cursor',join(homedir(),'.cursor')]].filter(([name,dir])=>has(name)||existsSync(dir)).map(([name])=>name);
+ const agents=found.length?found:['codex','cursor']; // none found: the open directory, which both read
+ const dirOf=agent=>agent==='claude'?skillDirs.claude:skillDirs.agents,outcome=new Map();
+ for(const dir of new Set(agents.map(dirOf))){try{outcome.set(dir,installSkill(dir));}catch(error){outcome.set(dir,error.message);}}
+ const installed=agents.filter(agent=>!outcome.get(dirOf(agent))).map(agent=>({agent,path:dirOf(agent)}));
+ const refused=[...outcome].filter(([,reason])=>reason).map(([path,reason])=>({path,reason}));
+ // 4. The onboarding screen follows along; it knows the two clients below.
+ // Best effort: no report is no failure.
+ const reporter=values.agent??found.find(agent=>agent!=='cursor');
+ let reported=false;
+ if(['claude','codex'].includes(reporter)&&installed.length&&!refused.length){
+  try{
+   const session=await call('wizard','start','--client',reporter,...repository().map(([key,value])=>`--${key.replaceAll('_','-')}=${value}`),'--project',project.id);
+   const tasks=[['sign_in','Sign in',me.data.user.email||new URL(shown.endpoint).host],['project','Choose the project',project.name],['skill','Install the Caveman Cloud skill',[...new Set(installed.map(i=>labels[i.agent]))].join(', ')]].map(([id,label,detail])=>({id,label,status:'done',detail:String(detail).slice(0,240)}));
+   reported=!session.code&&!(await call('wizard','update',session.data.id,'--phase','completed','--tasks',JSON.stringify(tasks),'--project',project.id)).code;
+  }catch{}
+ }
+ const next=`Open ${labels[reporter??found[0]]??'your coding agent'} in your repository and ask: "Set up Caveman Cloud for this repository."`;
+ out({ok:!refused.length,signed_in:true,api:shown.endpoint,project:{id:project.id,name:project.name},skill:{version,installed,refused},onboarding_reported:reported,next},[
+  `Signed in as ${plain(me.data.user.email)} at ${shown.endpoint}`,`Project ${plain(project.name)} (${project.id})`,
+  ...[...new Set(installed.map(i=>i.path))].map(path=>`Installed the Caveman Cloud skill for ${installed.filter(i=>i.path===path).map(i=>labels[i.agent]).join(' and ')}: ${path}`),
+  ...refused.map(r=>`Left ${r.path} alone: ${r.reason}`),'',next]);
+ return refused.length?1:0;
 }
 
 const argv=process.argv.slice(2);
+// What only the operation form of `evals validate` and `evals run` takes.
+// A bare id is the experiment to run, unless it is the value of --project.
+const operationInput=(arg,i,args)=>/^--(file|stdin|workbench-id|scope|concurrency|outputs|wait|wait-timeout|idempotency-key|out)(=|$)/.test(arg)||args[i-1]!=='--project'&&/^[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(arg);
+// `cvm setup` with flags or nothing is onboarding; `cvm setup show|assert|hold` are operations.
+const onboarding=argv[0]==='setup'&&!(argv[1]&&!argv[1].startsWith('-'));
+// A skill cvm installed follows the installed cvm: an upgrade refreshes it on
+// the next command. Nothing is created here, and nothing here fails a command.
+if(!['--version','-v'].includes(argv[0])&&!(onboarding&&argv.includes('--remove'))){
+ for(const dir of Object.values(skillDirs))try{if(readFileSync(join(dir,marker),'utf8')!==version)installSkill(dir);}catch{}
+}
 if(argv[0]==='--version'||argv[0]==='-v'){
- process.stdout.write(JSON.parse(readFileSync(new URL('../package.json',import.meta.url),'utf8')).version+'\n');
-}else if(argv[0]==='login'){
- login(argv.slice(1));
+ process.stdout.write(version+'\n');
+}else if(['login','logout'].includes(argv[0])||onboarding){
+ // No TTY needed: a coding agent runs these through its shell, and the person
+ // confirms the sign-in in the browser.
+ try{process.exitCode=await {login:loginCommand,logout,setup}[argv[0]](argv.slice(1));}
+ catch(error){
+  const exit=error.exitCode??1;
+  process.stdout.write(JSON.stringify({schema_version:1,ok:false,status:'failed',error:{code:error.exitCode?error.code:'cave_failed',message:error.message}})+'\n');
+  process.exitCode=exit;
+ }
 }else if(argv[0]==='mcp'&&argv.length===1){
  const {serveCloudMCP}=await import('../dist/cloud-mcp.mjs');
  // A launcher may narrow the server to the operations one task needs.
  const granted=(process.env.CAVE_MCP_OPERATIONS??'').split(',').map(id=>id.trim()).filter(Boolean);
  await serveCloudMCP({context,...(granted.length?{grantedOperations:granted}:{})});
+}else if(argv[0]==='evals'&&(argv[1]==='init'||['validate','run'].includes(argv[1])&&!argv.slice(2).some(operationInput))){
+ // An eval file (*.eval.json) from nothing to a gated run. `evals validate
+ // --file MANIFEST` and `evals run WORKBENCH_ID` stay the client's own.
+ const evals=await import('./evals.mjs');
+ process.exitCode=await {init:evals.evalsInit,validate:evals.evalsValidate,run:evals.evalsRun}[argv[1]](argv.slice(2),{context});
+}else if(argv[0]==='evals'&&['ci','watch'].includes(argv[1])){
+ const {evalsCI,evalsWatch}=await import('./ci.mjs');
+ process.exitCode=await (argv[1]==='ci'?evalsCI:evalsWatch)(argv.slice(2),{context,login:loginCommand});
 }else{
- const {runCloudCLI}=await import('../dist/cloud-client.mjs');
- process.exitCode=await runCloudCLI(argv,{context,login});
+ const {runCloudCLI}=await client();
+ process.exitCode=await runCloudCLI(argv,{context,login:loginCommand});
 }