@xenosystem/agent-sdk 0.8.12

package/dist/control-plane/index.cjs

@@ -0,0 +1,7 @@
+"use strict";var W=Object.defineProperty;var Re=Object.getOwnPropertyDescriptor;var we=Object.getOwnPropertyNames;var ve=Object.prototype.hasOwnProperty;var ke=(n,e)=>{for(var t in e)W(n,t,{get:e[t],enumerable:!0})},Ae=(n,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of we(e))!ve.call(n,o)&&o!==t&&W(n,o,{get:()=>e[o],enumerable:!(r=Re(e,o))||r.enumerable});return n};var ye=n=>Ae(W({},"__esModule",{value:!0}),n);var qe={};ke(qe,{AGENT_DAEMON_PROTOCOL_VERSION:()=>A,AgentDaemonClient:()=>H,AgentDaemonServer:()=>q,AgentEventStore:()=>x,AgentRunController:()=>J,AgentRunStore:()=>I,MonitorManager:()=>Q,MonitorStopTool:()=>Z,MonitorTool:()=>X,OtelExporter:()=>Y,UsageAccumulator:()=>M,UsageLedger:()=>K,WorkflowPlanner:()=>y,WorkflowRuntime:()=>G,WorkflowStore:()=>U,acquireControlPlaneLock:()=>D,createAgentRunId:()=>ce,getAgentRunDir:()=>Fe,getAgentRunStoreDir:()=>Le});module.exports=ye(qe);var ue=require("node:crypto"),d=require("node:fs"),de=require("node:os"),u=require("node:path");var E="0.8.11";var h=require("node:fs"),$=require("node:os"),re=require("node:path");function Se(){return new Date().toISOString()}function Ee(){return new Date(Date.now()-Math.floor(process.uptime()*1e3)).toISOString()}function ne(n){try{return JSON.parse((0,h.readFileSync)(n,"utf8"))}catch{return null}}function De(n){if(!n||n<=0)return!1;try{return process.kill(n,0),!0}catch{return!1}}function xe(n){return n.hostname!==(0,$.hostname)()?!0:De(n.pid)}function te(n,e){(0,h.mkdirSync)((0,re.dirname)(n),{recursive:!0}),(0,h.writeFileSync)(n,JSON.stringify(e,null,2)+`
+`,{encoding:"utf8",flag:"wx"})}function Ie(n,e){let t=ne(n);t?.pid!==e.pid||t.hostname!==e.hostname||(0,h.rmSync)(n,{force:!0})}function D(n,e,t){let r=Se(),o={schemaVersion:1,name:e,pid:process.pid,hostname:(0,$.hostname)(),processStartedAt:Ee(),version:t,acquiredAt:r,updatedAt:r};try{te(n,o)}catch(i){if(i.code!=="EEXIST")throw i;let a=ne(n);if(a&&xe(a))throw new Error(`${e} is already locked by PID ${a.pid} on ${a.hostname}.`);(0,h.rmSync)(n,{force:!0}),te(n,o)}return{record:o,release:()=>{Ie(n,o)}}}var ie=require("node:crypto"),R=require("node:fs"),k=require("node:path");function oe(n){return(0,k.basename)(n).replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,96)}function se(n){return(0,R.existsSync)(n)?(0,R.readFileSync)(n,"utf8").split(/\r?\n/).map(e=>e.trim()).filter(Boolean).map(e=>{try{return JSON.parse(e)}catch{return null}}).filter(e=>e!==null):[]}var x=class{constructor(e){this.runsDir=e;(0,R.mkdirSync)(this.runsDir,{recursive:!0})}runsDir;pathFor(e){return(0,k.join)(this.runsDir,oe(e),"events.jsonl")}append(e,t,r={},o=new Date().toISOString()){let i=this.pathFor(e);(0,R.mkdirSync)((0,k.dirname)(i),{recursive:!0});let s=D(`${i}.lock`,`events:${oe(e)}`,E);try{let a=se(i).reduce((N,m,P)=>Math.max(N,m.sequence??P),-1)+1,f={schemaVersion:1,eventId:`event_${(0,ie.randomUUID)()}`,sequence:a,runId:e,type:t,timestamp:o,payload:r};return(0,R.appendFileSync)(i,`${JSON.stringify(f)}
+`,"utf8"),f}finally{s.release()}}read(e){return se(this.pathFor(e))}tail(e,t=100){let r=Math.max(0,Math.min(1e4,Math.trunc(t)));return r===0?[]:this.read(e).slice(-r)}};var Te=1,Pe=(0,u.join)((0,de.homedir)(),".xeno-agent"),be=(0,u.join)(process.env.XENO_AGENT_HOME??Pe,"daemon"),F=(0,u.join)(be,"runs");function p(){return new Date().toISOString()}function Oe(n=new Date){return n.toISOString().replace(/[^0-9]/g,"").slice(0,14)}function L(n){return n.replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,80)}function j(n){return(0,u.resolve)(n)}function O(n){return j(n).toLowerCase()}function ae(n,e){let t=O(n),r=O(e);return t===r||t.startsWith(`${r}\\`)||t.startsWith(`${r}/`)}function _e(n,e){return!!(O(n.cwd)===O(e)||n.git?.root&&ae(e,n.git.root)||n.git?.worktree&&ae(e,n.git.worktree))}function Ce(n){return L(Buffer.from(j(n)).toString("base64url"))}function Ue(){return{input:0,output:0,total:0}}function b(n){try{return JSON.parse((0,d.readFileSync)(n,"utf8"))}catch{return null}}function Me(n){return n instanceof Error&&/\balready locked by PID\b/.test(n.message)}function Ne(n,e){(0,d.mkdirSync)((0,u.dirname)(n),{recursive:!0});let t=`${n}.${process.pid}.${Date.now()}.tmp`;(0,d.writeFileSync)(t,JSON.stringify(e,null,2)+`
+`,"utf8"),(0,d.renameSync)(t,n)}function Ve(n){if(!n||n<=0)return!1;try{return process.kill(n,0),!0}catch{return!1}}function We(n){return n==="completed"||n==="failed"||n==="cancelled"||n==="interrupted"}function $e(n,e){return n.pinned!==e.pinned?n.pinned?-1:1:Date.parse(e.updatedAt)-Date.parse(n.updatedAt)}function Le(){return F}function Fe(n){return(0,u.join)(F,n)}function ce(n=new Date){return`run_${Oe(n)}_${(0,ue.randomUUID)().slice(0,8)}`}var I=class{constructor(e=F){this.runsDir=e;(0,d.mkdirSync)(this.runsDir,{recursive:!0}),this.eventStore=new x(this.runsDir)}runsDir;eventStore;create(e){let t=ce(),r=(0,u.join)(this.runsDir,t);(0,d.mkdirSync)(r,{recursive:!0});let o=p(),i=(0,u.join)(r,"events.jsonl"),s={schemaVersion:Te,runId:t,sessionId:t,rootRunId:t,cwd:j(e.cwd),workspaceId:Ce(e.cwd),prompt:e.prompt,...e.title?{title:e.title}:{},status:"starting",model:e.model,...e.effort?{effort:e.effort}:{},...e.agent?{agent:e.agent}:{},...e.git?{git:e.git}:{},permissionMode:e.permissionMode,...e.cliVersion?{createdByCliVersion:e.cliVersion}:{},createdBySdkVersion:e.sdkVersion??E,createdAt:o,updatedAt:o,lastActivityAt:o,pinned:!!e.pinned,attachedClients:0,...e.cliVersion?{cliVersion:e.cliVersion}:{},...e.sdkVersion?{sdkVersion:e.sdkVersion}:{},stdoutPath:(0,u.join)(r,"stdout.log"),stderrPath:(0,u.join)(r,"stderr.log"),eventsPath:i,usage:Ue(),children:[],tags:[]};return(0,d.writeFileSync)(s.stdoutPath,"","utf8"),(0,d.writeFileSync)(s.stderrPath,"","utf8"),(0,d.writeFileSync)(s.eventsPath,"","utf8"),this.write(s),this.appendEvent(t,"run_created",{cwd:s.cwd,model:s.model,...s.agent?{agent:s.agent}:{},...s.git?{git:s.git}:{},permissionMode:s.permissionMode,pinned:s.pinned}),s}get(e){let t=b(this.recordPath(e));return t?this.refreshRecordStatus(t):null}list(e={}){if(!(0,d.existsSync)(this.runsDir))return[];let t=(0,d.readdirSync)(this.runsDir,{withFileTypes:!0}).filter(r=>r.isDirectory()).map(r=>{try{return this.get(r.name)}catch(o){if(Me(o))return b(this.recordPath(r.name));throw o}}).filter(r=>r!==null).filter(r=>e.all||!e.cwd||_e(r,e.cwd)).filter(r=>!e.status||e.status.includes(r.status)).sort($e);return typeof e.limit=="number"&&e.limit>0?t.slice(0,e.limit):t}markSpawned(e,t,r){return this.update(e,o=>({...o,status:"running",workerPid:t,...r?{workerVersion:r}:{},startedAt:o.startedAt??p(),lastActivityAt:p()}))}markStarted(e,t){return this.update(e,r=>({...r,status:"running",workerPid:t.pid,...t.workerVersion?{workerVersion:t.workerVersion}:{},...t.model?{model:t.model}:{},...t.effort?{effort:t.effort}:{},startedAt:r.startedAt??p(),lastActivityAt:p()}))}markCompleted(e,t){return this.update(e,r=>({...r,status:t.status,...t.statusReason?{statusReason:t.statusReason}:{},exitCode:t.exitCode??null,usage:t.usage??r.usage,endedAt:p(),lastActivityAt:p()}))}markCancelled(e,t){return this.update(e,r=>({...r,status:"cancelled",statusReason:t,endedAt:p(),lastActivityAt:p()}))}markPaused(e,t="Paused by user."){let r=this.update(e,o=>({...o,status:"paused",statusReason:t,lastActivityAt:p()}));return r&&this.appendEvent(e,"run_paused",{reason:t}),r}markResumed(e,t="Resumed by user."){let r=this.update(e,o=>{let i={...o,status:"running",statusReason:t,lastActivityAt:p()};return delete i.endedAt,delete i.exitCode,i});return r&&this.appendEvent(e,"run_resumed",{reason:t}),r}setPinned(e,t){let r=this.update(e,o=>({...o,pinned:t,lastActivityAt:p()}));return r&&this.appendEvent(e,t?"run_pinned":"run_unpinned",{pinned:t}),r}appendEvent(e,t,r={}){let o=b(this.recordPath(e)),i=this.eventStore.append(e,t,r);o&&this.update(e,s=>({...s,lastActivityAt:i.timestamp}))}readEvents(e){return this.get(e)?this.eventStore.read(e):[]}delete(e){(0,d.rmSync)((0,u.join)(this.runsDir,e),{recursive:!0,force:!0})}refreshRecordStatus(e){if(We(e.status))return e;if(e.workerPid&&!Ve(e.workerPid)){let t={...e,status:"failed",statusReason:"Worker process is no longer running and did not record a terminal status.",endedAt:e.endedAt??p(),updatedAt:p()};return this.write(t),t}return e}update(e,t){let r=b(this.recordPath(e));if(!r)return null;let o=t(r);return o.updatedAt=p(),this.write(o),o}write(e){let t=D((0,u.join)(this.runDir(e.runId),"run.lock"),`run:${e.runId}`,E);try{Ne(this.recordPath(e.runId),e)}finally{t.release()}}recordPath(e){return(0,u.join)(this.runsDir,L((0,u.basename)(e)),"run.json")}runDir(e){return(0,u.join)(this.runsDir,L((0,u.basename)(e)))}};function le(n){return n==="completed"||n==="failed"||n==="cancelled"||n==="interrupted"}var J=class{constructor(e={}){this.options=e;this.store=e.store??new I}options;store;create(e){return this.store.create(e)}async start(e){let t=this.create(e);if(!this.options.spawn)return t;try{let r=await this.options.spawn(t),o=this.store.markSpawned(t.runId,r.pid,r.workerVersion);if(!o)throw new Error(`Run disappeared during spawn: ${t.runId}`);return this.store.appendEvent(t.runId,"run_started",{pid:r.pid}),o}catch(r){let o=r instanceof Error?r.message:String(r);throw this.store.markCompleted(t.runId,{status:"failed",statusReason:o,exitCode:null}),this.store.appendEvent(t.runId,"run_start_failed",{reason:o}),r}}get(e){return this.store.get(e)}list(e={}){return this.store.list(e)}events(e,t){let r=this.store.readEvents(e);return t===void 0?r:r.slice(-Math.max(0,Math.trunc(t)))}async stop(e,t="Stopped by user."){let r=this.store.get(e);if(!r||le(r.status))return r;await this.options.stop?.(r,t);let o=this.store.markCancelled(e,t);return o&&this.store.appendEvent(e,"run_cancelled",{reason:t}),o}async pause(e,t="Paused by user."){let r=this.store.get(e);return!r||le(r.status)||r.status==="paused"?r:(await this.options.pause?.(r,t),this.store.markPaused(e,t))}async resume(e,t="Resumed by user."){let r=this.store.get(e);return!r||r.status!=="paused"?r:(await this.options.resume?.(r,t),this.store.markResumed(e,t))}complete(e,t,r={}){let o=this.store.markCompleted(e,{status:t,...r.reason?{statusReason:r.reason}:{},...r.exitCode!==void 0?{exitCode:r.exitCode}:{},...r.usage?{usage:r.usage}:{}});return o&&this.store.appendEvent(e,`run_${t}`,{...r.reason?{reason:r.reason}:{}}),o}};var _=require("node:crypto"),A=1;function je(n,e){if(!n)return!1;let t=Buffer.from(n),r=Buffer.from(e);return t.length===r.length&&(0,_.timingSafeEqual)(t,r)}var q=class{constructor(e={}){this.options=e}options;handlers=new Map;register(e,t){let r=e.trim();if(!r)throw new Error("Daemon method name cannot be empty.");if(this.handlers.has(r))throw new Error(`Daemon method already registered: ${r}`);return this.handlers.set(r,t),this}registerController(e){return this.register("runs.start",t=>e.start(t)).register("runs.get",t=>e.get(t.runId)).register("runs.list",t=>e.list(t??{})).register("runs.events",t=>{let r=t;return e.events(r.runId,r.limit)}).register("runs.stop",t=>{let r=t;return e.stop(r.runId,r.reason)}).register("runs.pause",t=>{let r=t;return e.pause(r.runId,r.reason)}).register("runs.resume",t=>{let r=t;return e.resume(r.runId,r.reason)})}async handle(e){if(e.protocolVersion!==A)return this.error(e.id,"PROTOCOL_MISMATCH",`Unsupported protocol version: ${e.protocolVersion}`);if(this.options.authToken&&!je(e.authToken,this.options.authToken))return this.error(e.id,"UNAUTHORIZED","Daemon authentication failed.");let t=this.handlers.get(e.method);if(!t)return this.error(e.id,"METHOD_NOT_FOUND",`Unknown daemon method: ${e.method}`);try{return{protocolVersion:A,id:e.id,result:await t(e.params,e)}}catch(r){return this.error(e.id,"INTERNAL_ERROR",r instanceof Error?r.message:String(r))}}error(e,t,r){return{protocolVersion:A,id:e,error:{code:t,message:r}}}},H=class{constructor(e,t={}){this.transport=e;this.options=t}transport;options;async request(e,t){let r={protocolVersion:A,id:`request_${(0,_.randomUUID)()}`,method:e,params:t,...this.options.authToken?{authToken:this.options.authToken}:{}},o=await this.transport(r);if(o.protocolVersion!==A||o.id!==r.id)throw new Error("Invalid daemon response identity.");if("error"in o){let i=new Error(o.error.message);throw i.code=o.error.code,i}return o.result}};var B=require("node:crypto"),c=require("node:fs"),ge=require("node:os"),g=require("node:path");function C(n){return(0,g.basename)(n).replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,96)}function z(n){try{return JSON.parse((0,c.readFileSync)(n,"utf8"))}catch{return null}}function pe(n,e){(0,c.mkdirSync)((0,g.dirname)(n),{recursive:!0});let t=`${n}.${process.pid}.${Date.now()}.tmp`;(0,c.writeFileSync)(t,`${JSON.stringify(e,null,2)}
+`,"utf8"),(0,c.renameSync)(t,n)}var y=class{plan(e){if(e.schemaVersion!==1)throw new Error("Unsupported workflow schema version.");if(!e.id.trim()||!e.name.trim())throw new Error("Workflow id and name are required.");let t=new Map;for(let s of e.nodes){if(!s.id.trim())throw new Error("Workflow node id cannot be empty.");if(t.has(s.id))throw new Error(`Duplicate workflow node: ${s.id}`);t.set(s.id,s)}for(let s of e.nodes)for(let a of s.dependsOn??[]){if(!t.has(a))throw new Error(`Workflow node ${s.id} depends on unknown node ${a}.`);if(a===s.id)throw new Error(`Workflow node ${s.id} cannot depend on itself.`)}let r=new Set(t.keys()),o=new Set,i=[];for(;r.size>0;){let s=[...r].filter(a=>(t.get(a)?.dependsOn??[]).every(f=>o.has(f))).sort();if(s.length===0)throw new Error("Workflow dependency graph contains a cycle.");i.push(s);for(let a of s)r.delete(a),o.add(a)}return{workflowId:e.id,waves:i}}},U=class{constructor(e=(0,g.join)(process.env.XENO_AGENT_HOME??(0,g.join)((0,ge.homedir)(),".xeno-agent"),"workflows")){this.rootDir=e;(0,c.mkdirSync)(this.definitionsDir(),{recursive:!0}),(0,c.mkdirSync)(this.runsDir(),{recursive:!0})}rootDir;saveDefinition(e){return new y().plan(e),pe((0,g.join)(this.definitionsDir(),`${C(e.id)}.json`),e),e}getDefinition(e){return z((0,g.join)(this.definitionsDir(),`${C(e)}.json`))}listDefinitions(){return(0,c.readdirSync)(this.definitionsDir(),{withFileTypes:!0}).filter(e=>e.isFile()&&e.name.endsWith(".json")).map(e=>z((0,g.join)(this.definitionsDir(),e.name))).filter(e=>e!==null)}createRun(e){new y().plan(e);let t=new Date().toISOString(),r={schemaVersion:1,runId:`workflow_run_${(0,B.randomUUID)()}`,workflowId:e.id,status:"queued",createdAt:t,updatedAt:t,nodes:Object.fromEntries(e.nodes.map(o=>[o.id,{status:"pending"}]))};return this.writeRun(r),this.appendEvent(r.runId,"workflow_created",{}),r}getRun(e){return z(this.runPath(e))}updateRun(e,t){let r=this.getRun(e);if(!r)throw new Error(`Workflow run not found: ${e}`);let o=t(r);return o.updatedAt=new Date().toISOString(),this.writeRun(o),o}appendEvent(e,t,r,o){let i={schemaVersion:1,eventId:`workflow_event_${(0,B.randomUUID)()}`,runId:e,type:t,timestamp:new Date().toISOString(),...o?{nodeId:o}:{},payload:r},s=this.eventsPath(e);return(0,c.mkdirSync)((0,g.dirname)(s),{recursive:!0}),(0,c.appendFileSync)(s,`${JSON.stringify(i)}
+`,"utf8"),i}readEvents(e){let t=this.eventsPath(e);return(0,c.existsSync)(t)?(0,c.readFileSync)(t,"utf8").split(/\r?\n/).filter(Boolean).flatMap(r=>{try{return[JSON.parse(r)]}catch{return[]}}):[]}writeRun(e){pe(this.runPath(e.runId),e)}definitionsDir(){return(0,g.join)(this.rootDir,"definitions")}runsDir(){return(0,g.join)(this.rootDir,"runs")}runPath(e){return(0,g.join)(this.runsDir(),C(e),"run.json")}eventsPath(e){return(0,g.join)(this.runsDir(),C(e),"events.jsonl")}},G=class{constructor(e=new U,t=new y){this.store=e;this.planner=t}store;planner;async run(e,t){let r=this.planner.plan(e),o=this.store.createRun(e);o=this.store.updateRun(o.runId,a=>({...a,status:"running"})),this.store.appendEvent(o.runId,"workflow_started",{waves:r.waves.length});let i=Math.max(1,Math.trunc(e.maxConcurrency??4)),s=!1;for(let a of r.waves)for(let f=0;f<a.length;f+=i){let N=a.slice(f,f+i);await Promise.all(N.map(async m=>{let P=e.nodes.find(l=>l.id===m);if((P.dependsOn??[]).some(l=>this.store.getRun(o.runId)?.nodes[l]?.status!=="completed")||s&&e.failFast!==!1){this.store.updateRun(o.runId,l=>({...l,nodes:{...l.nodes,[m]:{status:"skipped",completedAt:new Date().toISOString()}}})),this.store.appendEvent(o.runId,"node_skipped",{},m);return}let V=new Date().toISOString();o=this.store.updateRun(o.runId,l=>({...l,nodes:{...l.nodes,[m]:{status:"running",startedAt:V}}})),this.store.appendEvent(o.runId,"node_started",{},m);try{let l=await t(P,{run:o,definition:e});this.store.updateRun(o.runId,S=>({...S,nodes:{...S.nodes,[m]:{status:"completed",startedAt:V,completedAt:new Date().toISOString(),output:l}}})),this.store.appendEvent(o.runId,"node_completed",{},m)}catch(l){s=!0;let S=l instanceof Error?l.message:String(l);this.store.updateRun(o.runId,ee=>({...ee,nodes:{...ee.nodes,[m]:{status:"failed",startedAt:V,completedAt:new Date().toISOString(),error:S}}})),this.store.appendEvent(o.runId,"node_failed",{error:S},m)}}))}return o=this.store.updateRun(o.runId,a=>({...a,status:s?"failed":"completed",completedAt:new Date().toISOString()})),this.store.appendEvent(o.runId,s?"workflow_failed":"workflow_completed",{}),o}};var me=require("node:crypto"),Q=class{constructor(e=1e4){this.maxEvents=e;if(!Number.isInteger(e)||e<1)throw new Error("maxEvents must be a positive integer.")}maxEvents;sources=new Map;events=[];register(e){if(!e.id.trim())throw new Error("Monitor source id cannot be empty.");if(this.sources.has(e.id))throw new Error(`Monitor source already registered: ${e.id}`);return this.sources.set(e.id,{source:e,running:!1}),this}async start(e,t=1e3){let r=this.require(e);if(r.running)return this.snapshot(e);await r.source.start?.(),r.running=!0,await this.poll(e);let o=Math.max(25,Math.trunc(t));return r.timer=setInterval(()=>{this.poll(e).catch(()=>{})},o),r.timer.unref?.(),this.snapshot(e)}async poll(e){let o=(await this.require(e).source.poll()).map(i=>({schemaVersion:1,eventId:`monitor_event_${(0,me.randomUUID)()}`,sourceId:e,type:i.type,timestamp:i.timestamp??new Date().toISOString(),payload:i.payload}));return this.events.push(...o),this.events.length>this.maxEvents&&this.events.splice(0,this.events.length-this.maxEvents),o}async stop(e){let t=this.require(e);return t.timer&&clearInterval(t.timer),t.timer=void 0,t.running&&await t.source.stop?.(),t.running=!1,this.snapshot(e)}async stopAll(){await Promise.all([...this.sources.keys()].map(e=>this.stop(e)))}snapshot(e,t=100){let r=this.require(e);return{sourceId:e,running:r.running,events:this.events.filter(o=>o.sourceId===e).slice(-Math.max(0,Math.trunc(t)))}}list(){return[...this.sources].map(([e,t])=>({sourceId:e,running:t.running}))}require(e){let t=this.sources.get(e);if(!t)throw new Error(`Monitor source not found: ${e}`);return t}},X=class{constructor(e){this.manager=e}manager;execute(e){return this.manager.start(e.sourceId,e.intervalMs)}},Z=class{constructor(e){this.manager=e}manager;execute(e){return this.manager.stop(e.sourceId)}};var fe=require("node:crypto"),v=require("node:fs"),he=require("node:os"),T=require("node:path");function w(n){return Number.isFinite(n)?Math.max(0,n??0):0}var M=class{totalsValue={inputTokens:0,outputTokens:0,totalTokens:0,cachedInputTokens:0,estimatedCostUsd:0,events:0};add(e){let t=w(e.inputTokens),r=w(e.outputTokens);return this.totalsValue.inputTokens+=t,this.totalsValue.outputTokens+=r,this.totalsValue.totalTokens+=t+r,this.totalsValue.cachedInputTokens+=w(e.cachedInputTokens),this.totalsValue.estimatedCostUsd+=w(e.estimatedCostUsd),this.totalsValue.events+=1,this}snapshot(){return{...this.totalsValue}}};function Je(n,e){if(["runId","sessionId","workflowRunId","agentId","provider","model"].some(o=>e[o]!==void 0&&n[o]!==e[o]))return!1;let r=Date.parse(n.timestamp);return!(e.from&&r<Date.parse(e.from)||e.to&&r>Date.parse(e.to))}var K=class{path;constructor(e=(0,T.join)(process.env.XENO_AGENT_HOME??(0,T.join)((0,he.homedir)(),".xeno-agent"),"usage","events.jsonl")){this.path=e,(0,v.mkdirSync)((0,T.dirname)(e),{recursive:!0})}append(e){let t={...e,schemaVersion:1,eventId:`usage_${(0,fe.randomUUID)()}`,timestamp:e.timestamp??new Date().toISOString(),inputTokens:w(e.inputTokens),outputTokens:w(e.outputTokens),...e.cachedInputTokens!==void 0?{cachedInputTokens:w(e.cachedInputTokens)}:{},...e.estimatedCostUsd!==void 0?{estimatedCostUsd:w(e.estimatedCostUsd)}:{}};return(0,v.appendFileSync)(this.path,`${JSON.stringify(t)}
+`,"utf8"),t}query(e={}){return(0,v.existsSync)(this.path)?(0,v.readFileSync)(this.path,"utf8").split(/\r?\n/).filter(Boolean).flatMap(t=>{try{let r=JSON.parse(t);return Je(r,e)?[r]:[]}catch{return[]}}):[]}summarize(e={}){let t=new M;for(let r of this.query(e))t.add(r);return t.snapshot()}},Y=class{constructor(e){this.adapter=e}adapter;export(e){for(let t of e){let r={...t.provider?{provider:t.provider}:{},...t.model?{model:t.model}:{}};this.adapter.addCounter("xeno.usage.input_tokens",t.inputTokens,r),this.adapter.addCounter("xeno.usage.output_tokens",t.outputTokens,r),t.cachedInputTokens&&this.adapter.addCounter("xeno.usage.cached_input_tokens",t.cachedInputTokens,r),t.estimatedCostUsd&&this.adapter.addCounter("xeno.usage.estimated_cost_usd",t.estimatedCostUsd,r),this.adapter.recordEvent?.("xeno.usage.recorded",r)}}};0&&(module.exports={AGENT_DAEMON_PROTOCOL_VERSION,AgentDaemonClient,AgentDaemonServer,AgentEventStore,AgentRunController,AgentRunStore,MonitorManager,MonitorStopTool,MonitorTool,OtelExporter,UsageAccumulator,UsageLedger,WorkflowPlanner,WorkflowRuntime,WorkflowStore,acquireControlPlaneLock,createAgentRunId,getAgentRunDir,getAgentRunStoreDir});

package/dist/control-plane/index.d.cts

@@ -0,0 +1,403 @@
+type AgentRunStatus = "queued" | "starting" | "running" | "blocked" | "waiting_for_user" | "waiting_for_tool" | "waiting_for_hook" | "waiting_for_permission" | "paused" | "completed" | "failed" | "cancelled" | "interrupted" | "detached";
+interface AgentRunUsage {
+    input: number;
+    output: number;
+    total: number;
+    estimatedCostUsd?: number;
+}
+interface AgentRunAgentDefinitionRef {
+    name: string;
+    scope: "project" | "user" | "plugin" | "built-in";
+    path: string;
+    description?: string;
+    model?: string;
+}
+interface AgentRunRecord {
+    schemaVersion: 1;
+    runId: string;
+    sessionId: string;
+    rootRunId: string;
+    parentRunId?: string;
+    cwd: string;
+    workspaceId: string;
+    prompt: string;
+    title?: string;
+    status: AgentRunStatus;
+    statusReason?: string;
+    blockedReason?: string;
+    model: string;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max";
+    agent?: AgentRunAgentDefinitionRef;
+    permissionMode: "default" | "plan" | "acceptEdits" | "auto" | "dontAsk" | "bypassPermissions";
+    createdByCliVersion?: string;
+    createdBySdkVersion?: string;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string;
+    endedAt?: string;
+    lastActivityAt?: string;
+    pinned: boolean;
+    attachedClients: number;
+    workerPid?: number;
+    workerVersion?: string;
+    cliVersion?: string;
+    sdkVersion?: string;
+    stdoutPath: string;
+    stderrPath: string;
+    eventsPath: string;
+    exitCode?: number | null;
+    git?: {
+        root?: string;
+        originBranch?: string;
+        originCommit?: string;
+        branch?: string;
+        baseRef?: string;
+        commit?: string;
+        worktree?: string;
+    };
+    usage: AgentRunUsage;
+    children: string[];
+    tags: string[];
+}
+interface AgentRunEvent {
+    schemaVersion: 1;
+    eventId?: string;
+    sequence?: number;
+    runId: string;
+    type: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}
+interface AgentRunListOptions {
+    cwd?: string;
+    all?: boolean;
+    status?: AgentRunStatus[];
+    limit?: number;
+}
+interface AgentRunCreateInput {
+    prompt: string;
+    cwd: string;
+    model: string;
+    effort?: AgentRunRecord["effort"];
+    agent?: AgentRunAgentDefinitionRef;
+    permissionMode: AgentRunRecord["permissionMode"];
+    title?: string;
+    pinned?: boolean;
+    git?: AgentRunRecord["git"];
+    cliVersion?: string;
+    sdkVersion?: string;
+}
+declare function getAgentRunStoreDir(): string;
+declare function getAgentRunDir(runId: string): string;
+declare function createAgentRunId(date?: Date): string;
+declare class AgentRunStore {
+    private readonly runsDir;
+    private readonly eventStore;
+    constructor(runsDir?: string);
+    create(input: AgentRunCreateInput): AgentRunRecord;
+    get(runId: string): AgentRunRecord | null;
+    list(options?: AgentRunListOptions): AgentRunRecord[];
+    markSpawned(runId: string, pid: number, workerVersion?: string): AgentRunRecord | null;
+    markStarted(runId: string, input: {
+        pid: number;
+        workerVersion?: string;
+        model?: string;
+        effort?: AgentRunRecord["effort"];
+    }): AgentRunRecord | null;
+    markCompleted(runId: string, input: {
+        status: AgentRunStatus;
+        statusReason?: string;
+        exitCode?: number | null;
+        usage?: AgentRunUsage;
+    }): AgentRunRecord | null;
+    markCancelled(runId: string, reason: string): AgentRunRecord | null;
+    markPaused(runId: string, reason?: string): AgentRunRecord | null;
+    markResumed(runId: string, reason?: string): AgentRunRecord | null;
+    setPinned(runId: string, pinned: boolean): AgentRunRecord | null;
+    appendEvent(runId: string, type: string, payload?: Record<string, unknown>): void;
+    readEvents(runId: string): AgentRunEvent[];
+    delete(runId: string): void;
+    refreshRecordStatus(record: AgentRunRecord): AgentRunRecord;
+    private update;
+    private write;
+    private recordPath;
+    private runDir;
+}
+declare class AgentEventStore {
+    private readonly runsDir;
+    constructor(runsDir: string);
+    pathFor(runId: string): string;
+    append(runId: string, type: string, payload?: Record<string, unknown>, timestamp?: string): AgentRunEvent;
+    read(runId: string): AgentRunEvent[];
+    tail(runId: string, limit?: number): AgentRunEvent[];
+}
+interface AgentRunSpawnResult {
+    pid: number;
+    workerVersion?: string;
+}
+interface AgentRunControllerOptions {
+    store?: AgentRunStore;
+    spawn?: (record: AgentRunRecord) => AgentRunSpawnResult | Promise<AgentRunSpawnResult>;
+    stop?: (record: AgentRunRecord, reason: string) => void | Promise<void>;
+    pause?: (record: AgentRunRecord, reason: string) => void | Promise<void>;
+    resume?: (record: AgentRunRecord, reason: string) => void | Promise<void>;
+}
+declare class AgentRunController {
+    private readonly options;
+    readonly store: AgentRunStore;
+    constructor(options?: AgentRunControllerOptions);
+    create(input: AgentRunCreateInput): AgentRunRecord;
+    start(input: AgentRunCreateInput): Promise<AgentRunRecord>;
+    get(runId: string): AgentRunRecord | null;
+    list(options?: AgentRunListOptions): AgentRunRecord[];
+    events(runId: string, limit?: number): AgentRunEvent[];
+    stop(runId: string, reason?: string): Promise<AgentRunRecord | null>;
+    pause(runId: string, reason?: string): Promise<AgentRunRecord | null>;
+    resume(runId: string, reason?: string): Promise<AgentRunRecord | null>;
+    complete(runId: string, status: Extract<AgentRunStatus, "completed" | "failed" | "interrupted">, options?: {
+        reason?: string;
+        exitCode?: number | null;
+        usage?: AgentRunUsage;
+    }): AgentRunRecord | null;
+}
+declare const AGENT_DAEMON_PROTOCOL_VERSION: 1;
+interface AgentDaemonRequest<T = unknown> {
+    protocolVersion: typeof AGENT_DAEMON_PROTOCOL_VERSION;
+    id: string;
+    method: string;
+    params: T;
+    authToken?: string;
+}
+interface AgentDaemonError {
+    code: string;
+    message: string;
+}
+type AgentDaemonResponse<T = unknown> = {
+    protocolVersion: 1;
+    id: string;
+    result: T;
+} | {
+    protocolVersion: 1;
+    id: string;
+    error: AgentDaemonError;
+};
+type AgentDaemonHandler = (params: unknown, request: AgentDaemonRequest) => unknown | Promise<unknown>;
+type AgentDaemonTransport = (request: AgentDaemonRequest) => AgentDaemonResponse | Promise<AgentDaemonResponse>;
+declare class AgentDaemonServer {
+    private readonly options;
+    private readonly handlers;
+    constructor(options?: {
+        authToken?: string;
+    });
+    register(method: string, handler: AgentDaemonHandler): this;
+    registerController(controller: AgentRunController): this;
+    handle(request: AgentDaemonRequest): Promise<AgentDaemonResponse>;
+    private error;
+}
+declare class AgentDaemonClient {
+    private readonly transport;
+    private readonly options;
+    constructor(transport: AgentDaemonTransport, options?: {
+        authToken?: string;
+    });
+    request<TResult = unknown, TParams = unknown>(method: string, params: TParams): Promise<TResult>;
+}
+interface WorkflowNodeDefinition {
+    id: string;
+    dependsOn?: string[];
+    input?: unknown;
+}
+interface WorkflowDefinition {
+    schemaVersion: 1;
+    id: string;
+    name: string;
+    nodes: WorkflowNodeDefinition[];
+    maxConcurrency?: number;
+    failFast?: boolean;
+}
+type WorkflowNodeStatus = "pending" | "running" | "completed" | "failed" | "skipped";
+type WorkflowRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+interface WorkflowRunNodeRecord {
+    status: WorkflowNodeStatus;
+    startedAt?: string;
+    completedAt?: string;
+    output?: unknown;
+    error?: string;
+}
+interface WorkflowRunRecord {
+    schemaVersion: 1;
+    runId: string;
+    workflowId: string;
+    status: WorkflowRunStatus;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    nodes: Record<string, WorkflowRunNodeRecord>;
+}
+interface WorkflowEvent {
+    schemaVersion: 1;
+    eventId: string;
+    runId: string;
+    type: string;
+    timestamp: string;
+    nodeId?: string;
+    payload: Record<string, unknown>;
+}
+interface WorkflowPlan {
+    workflowId: string;
+    waves: string[][];
+}
+declare class WorkflowPlanner {
+    plan(definition: WorkflowDefinition): WorkflowPlan;
+}
+declare class WorkflowStore {
+    private readonly rootDir;
+    constructor(rootDir?: string);
+    saveDefinition(definition: WorkflowDefinition): WorkflowDefinition;
+    getDefinition(id: string): WorkflowDefinition | null;
+    listDefinitions(): WorkflowDefinition[];
+    createRun(definition: WorkflowDefinition): WorkflowRunRecord;
+    getRun(runId: string): WorkflowRunRecord | null;
+    updateRun(runId: string, updater: (record: WorkflowRunRecord) => WorkflowRunRecord): WorkflowRunRecord;
+    appendEvent(runId: string, type: string, payload: Record<string, unknown>, nodeId?: string): WorkflowEvent;
+    readEvents(runId: string): WorkflowEvent[];
+    private writeRun;
+    private definitionsDir;
+    private runsDir;
+    private runPath;
+    private eventsPath;
+}
+type WorkflowNodeExecutor = (node: WorkflowNodeDefinition, context: {
+    run: WorkflowRunRecord;
+    definition: WorkflowDefinition;
+}) => unknown | Promise<unknown>;
+declare class WorkflowRuntime {
+    private readonly store;
+    private readonly planner;
+    constructor(store?: WorkflowStore, planner?: WorkflowPlanner);
+    run(definition: WorkflowDefinition, executor: WorkflowNodeExecutor): Promise<WorkflowRunRecord>;
+}
+interface MonitorEvent {
+    schemaVersion: 1;
+    eventId: string;
+    sourceId: string;
+    type: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}
+interface MonitorSource {
+    id: string;
+    start?(): void | Promise<void>;
+    poll(): Array<Omit<MonitorEvent, "schemaVersion" | "eventId" | "sourceId" | "timestamp"> & {
+        timestamp?: string;
+    }> | Promise<Array<Omit<MonitorEvent, "schemaVersion" | "eventId" | "sourceId" | "timestamp"> & {
+        timestamp?: string;
+    }>>;
+    stop?(): void | Promise<void>;
+}
+interface MonitorSnapshot {
+    sourceId: string;
+    running: boolean;
+    events: MonitorEvent[];
+}
+declare class MonitorManager {
+    private readonly maxEvents;
+    private readonly sources;
+    private readonly events;
+    constructor(maxEvents?: number);
+    register(source: MonitorSource): this;
+    start(sourceId: string, intervalMs?: number): Promise<MonitorSnapshot>;
+    poll(sourceId: string): Promise<MonitorEvent[]>;
+    stop(sourceId: string): Promise<MonitorSnapshot>;
+    stopAll(): Promise<void>;
+    snapshot(sourceId: string, limit?: number): MonitorSnapshot;
+    list(): Array<{
+        sourceId: string;
+        running: boolean;
+    }>;
+    private require;
+}
+declare class MonitorTool {
+    private readonly manager;
+    constructor(manager: MonitorManager);
+    execute(input: {
+        sourceId: string;
+        intervalMs?: number;
+    }): Promise<MonitorSnapshot>;
+}
+declare class MonitorStopTool {
+    private readonly manager;
+    constructor(manager: MonitorManager);
+    execute(input: {
+        sourceId: string;
+    }): Promise<MonitorSnapshot>;
+}
+interface UsageAttribution {
+    runId?: string;
+    sessionId?: string;
+    workflowRunId?: string;
+    agentId?: string;
+    provider?: string;
+    model?: string;
+}
+interface UsageEvent extends UsageAttribution {
+    schemaVersion: 1;
+    eventId: string;
+    timestamp: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    estimatedCostUsd?: number;
+    metadata?: Record<string, string | number | boolean>;
+}
+interface UsageQuery extends UsageAttribution {
+    from?: string;
+    to?: string;
+}
+interface UsageTotals {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens: number;
+    estimatedCostUsd: number;
+    events: number;
+}
+declare class UsageAccumulator {
+    private totalsValue;
+    add(event: Pick<UsageEvent, "inputTokens" | "outputTokens" | "cachedInputTokens" | "estimatedCostUsd">): this;
+    snapshot(): UsageTotals;
+}
+declare class UsageLedger {
+    private readonly path;
+    constructor(path?: string);
+    append(input: Omit<UsageEvent, "schemaVersion" | "eventId" | "timestamp"> & {
+        timestamp?: string;
+    }): UsageEvent;
+    query(query?: UsageQuery): UsageEvent[];
+    summarize(query?: UsageQuery): UsageTotals;
+}
+interface OtelUsageAdapter {
+    addCounter(name: string, value: number, attributes: Readonly<Record<string, string>>): void;
+    recordEvent?(name: string, attributes: Readonly<Record<string, string>>): void;
+}
+declare class OtelExporter {
+    private readonly adapter;
+    constructor(adapter: OtelUsageAdapter);
+    export(events: readonly UsageEvent[]): void;
+}
+interface ControlPlaneLockRecord {
+    schemaVersion: 1;
+    name: string;
+    pid: number;
+    hostname: string;
+    processStartedAt: string;
+    version: string;
+    acquiredAt: string;
+    updatedAt: string;
+}
+interface ControlPlaneLockHandle {
+    record: ControlPlaneLockRecord;
+    release: () => void;
+}
+declare function acquireControlPlaneLock(path: string, name: string, version: string): ControlPlaneLockHandle;
+export { AGENT_DAEMON_PROTOCOL_VERSION, AgentDaemonClient, type AgentDaemonError, type AgentDaemonHandler, type AgentDaemonRequest, type AgentDaemonResponse, AgentDaemonServer, type AgentDaemonTransport, AgentEventStore, type AgentRunAgentDefinitionRef, AgentRunController, type AgentRunControllerOptions, type AgentRunCreateInput, type AgentRunEvent, type AgentRunListOptions, type AgentRunRecord, type AgentRunSpawnResult, type AgentRunStatus, AgentRunStore, type AgentRunUsage, type ControlPlaneLockHandle, type ControlPlaneLockRecord, type MonitorEvent, MonitorManager, type MonitorSnapshot, type MonitorSource, MonitorStopTool, MonitorTool, OtelExporter, type OtelUsageAdapter, UsageAccumulator, type UsageAttribution, type UsageEvent, UsageLedger, type UsageQuery, type UsageTotals, type WorkflowDefinition, type WorkflowEvent, type WorkflowNodeDefinition, type WorkflowNodeExecutor, type WorkflowNodeStatus, type WorkflowPlan, WorkflowPlanner, type WorkflowRunNodeRecord, type WorkflowRunRecord, type WorkflowRunStatus, WorkflowRuntime, WorkflowStore, acquireControlPlaneLock, createAgentRunId, getAgentRunDir, getAgentRunStoreDir };