@xeno-corporation/xeno-agent-sdk 0.6.8 → 0.6.11

package/README.md

@@ -2,6 +2,12 @@
 
 Core runtime for XENO agent-enabled products. It provides the agent loop, tool execution, permissions, sessions, memory, audit logging, and provider integration used across the XENO platform.
 
+## Runtime Ownership
+
+The ownership program targets P2 feature parity, but this checkout must be described by its generated audit rather than by the target. Run `npm run build && npm run compliance:ownership:artifacts` or inspect `docs/compliance/ownership-inventory.md`. Node remains an explicitly external host through P2, and development/build packages remain third-party build inputs. Do not claim that a release is fully proprietary, entirely Xeno-owned, or free of third-party runtime code unless the packaged release smoke prints the corresponding achieved level and the required provenance/counsel gates are complete.
+
+The canonical policy and engineering clean-room controls are under `ownership/`.
+
 ## Vision
 
 Every XENO creative app (Pixel, Motion, Sound) has an AI agent embedded directly into the interface. Users open a sidebar, type what they want ("remove the background from this layer", "cut the silence from this podcast", "match-cut these two clips"), and the agent translates that into tool calls against the app's engine. One request can span multiple apps: "Create a product video from these photos with background music" triggers coordinated work across Pixel, Motion, and Sound simultaneously.
@@ -25,8 +31,8 @@ With agent SDK:     User says "Create a product video" -> agents in all 3 apps c
 - **Session persistence** with checkpoints, transcript writing, and crash recovery
 - **Audit logging** in JSON-lines format (who, what, when, result)
 - **Delegation system**: planner/executor/reviewer sub-agent workflows
-- ESM-only, TypeScript 5.7.3, tsup build
-- Dependencies: chalk, glob, gray-matter
+- ESM-only, TypeScript 7 native typechecking, TypeScript 6 compiler-API compatibility, tsup build
+- Production dependencies: none
 
 ## Automation
 
@@ -65,7 +71,7 @@ src/
 |-----------|---------|-------------|
 | **Core Loop** | Agentic turn loop with tool dispatch, streaming, reducer | `AgentLoop`, `AgentLoopConfig` |
 | **Tools** | Registry pattern for tool registration + 6 built-in tools | `ToolRegistry`, `registry` |
-| **Security** | Permission engine with 4 modes, path sandboxing | `PermissionEngine`, `PermissionConfig` |
+| **Security** | Permission engine, filesystem/shell policy, optional OS containment | `PermissionEngine`, `PolicyEnforcerConfig` |
 | **Session** | Persistence, checkpoints, transcripts, locks, recovery | `SessionManager`, `CheckpointManager` |
 | **Identity** | Persona loading and resolution across 4 levels | `IdentityLoader`, `IdentityResolver` |
 | **Memory** | Hierarchical memory with budget management | `MemoryManager`, `MemoryBudget` |
@@ -173,12 +179,71 @@ Messages are JSON-serializable for cross-process IPC. Timeout and retry are buil
 
 ### Safety Features
 
-- **Path sandboxing**: agents cannot access files outside configured boundaries
+- **Policy enforcement**: canonical physical-path checks reject traversal through symlinks/junctions, UNC/device, extended-length, drive-relative, root-relative, alternate-data-stream, reserved-device, and ambiguous paths
+- **Shell policy**: parsed PowerShell/Bash file operands, redirections, and path parameters enforce read/write capabilities; unresolved dynamic filesystem operands fail closed
+- **Execution security levels**: `policy-only`, `process-hardened`, and `contained` are separate API contracts. The legacy `requireOsContainment: true` flag now means strict `contained` and never accepts process hardening as a substitute.
+- **Windows process hardening**: `executionLevel: "process-hardened"` uses a reduced primary token, low integrity for read-only execution, an explicit inherited-handle allowlist, a minimized environment, and a kill-on-close Job Object. It does not isolate filesystem reads or network access and is for trusted workspaces only.
+- **Fail-closed containment**: no platform currently advertises release-certified `contained` execution. A contained or untrusted request fails with `CONTAINMENT_UNAVAILABLE`; executable discovery is not treated as certification.
 - **Destructive action gates**: delete, overwrite, and shell commands require explicit approval
 - **Audit trail**: every tool call logged in JSON-lines format with trace IDs
 - **Risk classification**: each tool call classified as low/medium/high risk
 - **Permission rules**: per-tool, per-path override rules
 
+The policy layer and Windows process hardening are defense in depth, not a claim that arbitrary untrusted code is contained. See [Security Boundaries](docs/SECURITY_BOUNDARIES.md) for the capability matrix and migration contract.
+
+### Managed Shell Processes
+
+`UnifiedExecManager` is the canonical owner for pipe and PTY process lifecycles. `BackgroundProcessManager` remains the task-oriented compatibility facade and adds owner scoping, bounded file-backed output, same-process foreground-to-background promotion, completion events, input, resize, and human-writer leases.
+
+- `Bash` accepts `tty: true` only with `run_in_background: true`.
+- `TaskInput` writes to or waits on an interactive task. Input text is projected to byte-count/task metadata before audit, permission, callback, and transcript sinks.
+- PTY support is adapter based. Hosts register an optional `XenoPtyAdapter`; missing capability returns `PTY_UNAVAILABLE` and never silently falls back to a pipe.
+- App-server `exec.start` accepts `tty`, `cols`, and `rows`; `exec.resize` is owner scoped alongside write, output, list, and terminate.
+- `SessionManager.recordDirectShellResult` persists bounded local-command output as user-role untrusted context with semantic metadata, not as a fabricated model tool call.
+
+### Managed Tool Operations
+
+Tool calls now receive a stable operation ID, deadline, completion policy (`await`, `observe`, or `detach`), progress counters, terminal reason, and artifact evidence. Recovery snapshots are written atomically under the user control-plane directory, while redacted operation transitions are appended to a private JSONL ledger. Raw command text is not copied into operation lists or the ledger.
+
+- A promotable foreground `Bash` command moves to the background by changing presentation on the same process. PID, task/process IDs, output cursor, and deadline are retained; the command is never re-executed.
+- `TaskOutput({ task_id, offset })` remains a nonblocking compatibility read. `wait: true` adds an event-driven wait capped at 30 seconds and always reports explicit `Operation terminal: yes|no`, state, runtime, idle time, output delta, UTF-8-safe next offset, and suggested action.
+- Finite model-created background work defaults to `await`. The parent turn suspends without another provider request and resumes from a durable continuation notification after terminal output arrives. User stop, detach, clear, interrupt, or rewind cancels stale automatic continuation.
+- `expected_outputs` on `Bash` records generic file postconditions. Missing or unstable outputs fail the logical operation even after exit code 0; partial artifacts are still reported after timeout/failure.
+- `ReadImage` preflights format, dimensions, and bytes. The dependency-free `xeno-owned-raster` path performs owned PNG/DEFLATE decode and encode, JPEG, GIF, VP8/VP8L WebP decode, bounded SVG software rasterization, and resizing; BMP and Netpbm inputs normalize through the same owned PNG path. Oversized supported inputs become owner-private bounded PNG previews without an ambient decoder or canvas fallback. Private previews are removed during session cleanup and originals stay unchanged. The exact approved profiles and explicit rejections are documented in [`docs/owned-media-matrix.md`](docs/owned-media-matrix.md).
+
+Temporary rollback controls default to enabled: `XENO_TOOL_OPERATION_RUNTIME`, `XENO_AUTO_BACKGROUND_FOREGROUND_BASH`, `XENO_TASK_OUTPUT_WAIT`, `XENO_AUTO_TOOL_CONTINUATION`, and `XENO_READ_IMAGE_AUTO_PREVIEW`. Setting a control to `0` disables its optional behavior without deleting active tasks or persisted operation records.
+
+On Windows, ordinary managed pipe tasks use the existing kill-on-close Job Object launcher when available and report `windows-job-object`; the explicit `windows-tree-fallback` uses tree termination but is not reported as verified Job ownership. Persistent PowerShell defaults to Windows PowerShell 5.1. Set `XENO_POWERSHELL_EXECUTABLE=pwsh.exe` to use PowerShell 7. Process ownership and cleanup are not claims of untrusted-code containment.
+
+See [docs/managed-tool-operations.md](docs/managed-tool-operations.md) for the runtime and troubleshooting contract.
+
+### Agent Harness Reliability
+
+- Tool inputs are JSON-schema validated by default; malformed calls are returned to the model as typed errors.
+- Interrupted or orphaned tool exchanges are repaired before resumable history is sent back to a provider.
+- Repeated identical failing tool calls are circuit-broken before they can loop indefinitely.
+- Query lifecycle transitions are emitted as typed runtime events and guarded by idle, active-operation lease, and hard timeouts.
+- Context overflow triggers one semantic compact-and-retry path. Old tool payloads are compacted before conversation history is dropped, message count has a hard cap, and preflight token estimates are model-aware with an injectable exact-tokenizer seam.
+- The default tool registry demand-loads optional schemas through `ToolSearch` instead of advertising every full schema on every request.
+
+### Direct Provider Adapters
+
+Provider-normalized deployments can continue using the default Xeno API transport. Direct integrations are available from the provider subpath:
+
+```typescript
+import { createDirectProvider } from '@xeno-corporation/xeno-agent-sdk/providers'
+import { createXenoAgent } from '@xeno-corporation/xeno-agent-sdk'
+
+const provider = createDirectProvider({
+  kind: 'openai-responses', // 'anthropic' | 'openai-responses' | 'google' | 'openai-compatible'
+  apiKey: process.env.PROVIDER_API_KEY!,
+})
+
+const { agent } = await createXenoAgent({ provider })
+```
+
+The adapters translate streaming text, images, parallel tool calls/results, usage, cancellation, and typed failures for Messages, Responses, Gemini, and explicitly profiled chat-compatible endpoints. Generic endpoints require a capability profile and local HTTP requires an explicit local-network endpoint profile. See [docs/PROVIDER_CONFORMANCE.md](docs/PROVIDER_CONFORMANCE.md).
+
 ## Session Persistence
 
 - Sessions have unique IDs with embedded timestamps
@@ -209,7 +274,7 @@ Memory is injected into the system prompt with configurable token budgets to avo
 | **xeno-rt** (local) | OpenAI-compatible API on localhost | Offline, privacy, no cost |
 | **Ollama** (local) | OpenAI-compatible API | Alternative local provider |
 
-The SDK is provider-agnostic. Any OpenAI-compatible endpoint works. Provider selection and fallback logic are handled by the config subsystem.
+The SDK is provider-agnostic. OpenAI-compatible endpoints are supported through an explicit capability and endpoint-security profile; compatibility is verified by conformance fixtures rather than inferred from the endpoint label. Provider selection and fallback logic are handled by the config subsystem.
 
 ## Consumers
 
@@ -221,18 +286,30 @@ The SDK is provider-agnostic. Any OpenAI-compatible endpoint works. Provider sel
 | **xeno-sound** | Audio editing agent sidebar | "Master this podcast to -16 LUFS" |
 | **xeno-hub** | Orchestrator routing tasks between apps | "Create marketing materials" dispatches to Pixel + Motion + Sound |
 
-## Planned: React Component Library
+## Xeno-Owned UI
 
-A separate `/react` or `/ui` export will provide pre-built React components for embedding the agent interface in Electron-based XENO apps:
+The `/ui` subpath provides a framework-neutral controller, semantic accessibility view, and optional owned DOM renderer. It has no React runtime or peer dependency and remains isolated from the Node-only core entry point.
 
-- **ChatPanel** -- full agent sidebar with message history
-- **MessageBubble** -- individual messages (user, agent, system)
-- **ToolCallIndicator** -- real-time display of tool execution with status
-- **ThinkingState** -- streaming thinking/reasoning indicator
-- **PermissionPrompt** -- inline approval UI for destructive actions
-- **SessionSwitcher** -- switch between conversation sessions
+```ts
+import {
+  createAgentUiController,
+  mountAgentUi,
+} from "@xeno-corporation/xeno-agent-sdk/ui";
+
+const controller = createAgentUiController({
+  agent: myAgentLoop,
+  enablePermissionRequests: true,
+});
+const view = mountAgentUi(document.querySelector("#agent")!, controller, {
+  agentName: "Xeno Agent",
+});
+
+// App shutdown:
+view.dispose();
+controller.dispose();
+```
 
-These components will NOT live in the core SDK (no DOM dependencies in core). They will be a separate package entry point that apps can import independently.
+Framework integrations can subscribe to immutable controller snapshots and call `createAgentUiView` instead of mounting the DOM renderer. Renderer contract version `1` includes message streaming, tool state, token usage, cancellation, retry, permission decisions, safe markdown segments, keyboard submission, and accessible roles/live regions. See [the UI v1 migration guide](docs/migrations/sdk-ui-v1.md).
 
 ## Ecosystem Position
 
@@ -254,7 +331,8 @@ See [Full Ecosystem Report](../XENO%20CORPORATION%20-%20Full%20Ecosystem%20Repor
 ```bash
 npm install
 npm run build      # tsup -> ESM output
-npm run typecheck   # TypeScript 5.7.3 strict mode
+npm run typecheck   # TypeScript 7 native strict-mode check
+npm run typecheck:compat # TypeScript 6 compatibility check for API-based tooling
 ```
 
 ## License

package/dist/agents/metafile-esm.json

@@ -0,0 +1 @@
+{"inputs":{"src/utils/yaml.ts":{"bytes":5506,"imports":[],"format":"esm"},"src/agents/definitions.ts":{"bytes":20613,"imports":[{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"src/utils/yaml.ts","kind":"import-statement","original":"../utils/yaml.js"}],"format":"esm"},"src/agents/index.ts":{"bytes":34,"imports":[{"path":"src/agents/definitions.ts","kind":"import-statement","original":"./definitions.js"}],"format":"esm"}},"outputs":{"dist/agents/index.js":{"imports":[{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true}],"exports":["AgentDefinitionLoader","AgentDefinitionResolver","createAgentDefinitionFile","createAgentDefinitionPromptSection","getProjectAgentDefinitionDirs","getProjectAgentDefinitionsDir","getUserAgentDefinitionsDir","isValidAgentDefinitionName","renderAgentDefinition","renderAgentDefinitions","resolveAgentDefinition","resolveAgentToolPolicy","scanAgentDefinitions","toAgentDefinitionMetadata","validateAgentDefinition"],"entryPoint":"src/agents/index.ts","inputs":{"src/agents/definitions.ts":{"bytesInOutput":8825},"src/utils/yaml.ts":{"bytesInOutput":2211},"src/agents/index.ts":{"bytesInOutput":0}},"bytes":11511}}}

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

@@ -61,6 +61,8 @@ interface AgentRunRecord {
 }
 interface AgentRunEvent {
     schemaVersion: 1;
+    eventId?: string;
+    sequence?: number;
     runId: string;
     type: string;
     timestamp: string;
@@ -90,6 +92,7 @@ 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;
@@ -120,6 +123,268 @@ declare class AgentRunStore {
     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;
@@ -135,4 +400,4 @@ interface ControlPlaneLockHandle {
     release: () => void;
 }
 declare function acquireControlPlaneLock(path: string, name: string, version: string): ControlPlaneLockHandle;
-export { type AgentRunAgentDefinitionRef, type AgentRunCreateInput, type AgentRunEvent, type AgentRunListOptions, type AgentRunRecord, type AgentRunStatus, AgentRunStore, type AgentRunUsage, type ControlPlaneLockHandle, type ControlPlaneLockRecord, acquireControlPlaneLock, createAgentRunId, getAgentRunDir, getAgentRunStoreDir };
+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 };

package/dist/control-plane/index.js

@@ -1,4 +1,7 @@
-import{randomUUID as J}from"crypto";import{appendFileSync as M,existsSync as y,mkdirSync as l,readFileSync as L,readdirSync as U,renameSync as z,rmSync as j,writeFileSync as g}from"fs";import{homedir as q}from"os";import{basename as P,dirname as b,join as u,resolve as B}from"path";var m="0.6.4";import{mkdirSync as x,readFileSync as O,rmSync as v,writeFileSync as V}from"fs";import{hostname as k}from"os";import{dirname as _}from"path";function I(){return new Date().toISOString()}function N(){return new Date(Date.now()-Math.floor(process.uptime()*1e3)).toISOString()}function w(e){try{return JSON.parse(O(e,"utf8"))}catch{return null}}function T(e){if(!e||e<=0)return!1;try{return process.kill(e,0),!0}catch{return!1}}function F(e){return e.hostname!==k()?!0:T(e.pid)}function h(e,t){x(_(e),{recursive:!0}),V(e,JSON.stringify(t,null,2)+`
-`,{encoding:"utf8",flag:"wx"})}function $(e,t){let r=w(e);r?.pid!==t.pid||r.hostname!==t.hostname||v(e,{force:!0})}function S(e,t,r){let n=I(),s={schemaVersion:1,name:t,pid:process.pid,hostname:k(),processStartedAt:N(),version:r,acquiredAt:n,updatedAt:n};try{h(e,s)}catch(a){if(a.code!=="EEXIST")throw a;let c=w(e);if(c&&F(c))throw new Error(`${t} is already locked by PID ${c.pid} on ${c.hostname}.`);v(e,{force:!0}),h(e,s)}return{record:s,release:()=>{$(e,s)}}}var D=1,H=u(q(),".xeno-agent"),W=u(process.env.XENO_AGENT_HOME??H,"daemon"),A=u(W,"runs");function i(){return new Date().toISOString()}function G(e=new Date){return e.toISOString().replace(/[^0-9]/g,"").slice(0,14)}function R(e){return e.replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,80)}function p(e){return B(e)}function f(e){return p(e).toLowerCase()}function C(e,t){let r=f(e),n=f(t);return r===n||r.startsWith(`${n}\\`)||r.startsWith(`${n}/`)}function K(e,t){return!!(f(e.cwd)===f(t)||e.git?.root&&C(t,e.git.root)||e.git?.worktree&&C(t,e.git.worktree))}function X(e){return R(Buffer.from(p(e)).toString("base64url"))}function Z(){return{input:0,output:0,total:0}}function d(e){try{return JSON.parse(L(e,"utf8"))}catch{return null}}function Q(e){return e instanceof Error&&/\balready locked by PID\b/.test(e.message)}function Y(e,t){l(b(e),{recursive:!0});let r=`${e}.${process.pid}.${Date.now()}.tmp`;g(r,JSON.stringify(t,null,2)+`
-`,"utf8"),z(r,e)}function tt(e){if(!e||e<=0)return!1;try{return process.kill(e,0),!0}catch{return!1}}function et(e){return e==="completed"||e==="failed"||e==="cancelled"||e==="interrupted"}function rt(e,t){return e.pinned!==t.pinned?e.pinned?-1:1:Date.parse(t.updatedAt)-Date.parse(e.updatedAt)}function Rt(){return A}function At(e){return u(A,e)}function nt(e=new Date){return`run_${G(e)}_${J().slice(0,8)}`}var E=class{constructor(t=A){this.runsDir=t;l(this.runsDir,{recursive:!0})}runsDir;create(t){let r=nt(),n=u(this.runsDir,r);l(n,{recursive:!0});let s=i(),a=u(n,"events.jsonl"),o={schemaVersion:D,runId:r,sessionId:r,rootRunId:r,cwd:p(t.cwd),workspaceId:X(t.cwd),prompt:t.prompt,...t.title?{title:t.title}:{},status:"starting",model:t.model,...t.effort?{effort:t.effort}:{},...t.agent?{agent:t.agent}:{},...t.git?{git:t.git}:{},permissionMode:t.permissionMode,...t.cliVersion?{createdByCliVersion:t.cliVersion}:{},createdBySdkVersion:t.sdkVersion??m,createdAt:s,updatedAt:s,lastActivityAt:s,pinned:!!t.pinned,attachedClients:0,...t.cliVersion?{cliVersion:t.cliVersion}:{},...t.sdkVersion?{sdkVersion:t.sdkVersion}:{},stdoutPath:u(n,"stdout.log"),stderrPath:u(n,"stderr.log"),eventsPath:a,usage:Z(),children:[],tags:[]};return g(o.stdoutPath,"","utf8"),g(o.stderrPath,"","utf8"),g(o.eventsPath,"","utf8"),this.write(o),this.appendEvent(r,"run_created",{cwd:o.cwd,model:o.model,...o.agent?{agent:o.agent}:{},...o.git?{git:o.git}:{},permissionMode:o.permissionMode,pinned:o.pinned}),o}get(t){let r=d(this.recordPath(t));return r?this.refreshRecordStatus(r):null}list(t={}){if(!y(this.runsDir))return[];let r=U(this.runsDir,{withFileTypes:!0}).filter(n=>n.isDirectory()).map(n=>{try{return this.get(n.name)}catch(s){if(Q(s))return d(this.recordPath(n.name));throw s}}).filter(n=>n!==null).filter(n=>t.all||!t.cwd||K(n,t.cwd)).filter(n=>!t.status||t.status.includes(n.status)).sort(rt);return typeof t.limit=="number"&&t.limit>0?r.slice(0,t.limit):r}markSpawned(t,r,n){return this.update(t,s=>({...s,status:"running",workerPid:r,...n?{workerVersion:n}:{},startedAt:s.startedAt??i(),lastActivityAt:i()}))}markStarted(t,r){return this.update(t,n=>({...n,status:"running",workerPid:r.pid,...r.workerVersion?{workerVersion:r.workerVersion}:{},...r.model?{model:r.model}:{},...r.effort?{effort:r.effort}:{},startedAt:n.startedAt??i(),lastActivityAt:i()}))}markCompleted(t,r){return this.update(t,n=>({...n,status:r.status,...r.statusReason?{statusReason:r.statusReason}:{},exitCode:r.exitCode??null,usage:r.usage??n.usage,endedAt:i(),lastActivityAt:i()}))}markCancelled(t,r){return this.update(t,n=>({...n,status:"cancelled",statusReason:r,endedAt:i(),lastActivityAt:i()}))}markPaused(t,r="Paused by user."){let n=this.update(t,s=>({...s,status:"paused",statusReason:r,lastActivityAt:i()}));return n&&this.appendEvent(t,"run_paused",{reason:r}),n}markResumed(t,r="Resumed by user."){let n=this.update(t,s=>{let a={...s,status:"running",statusReason:r,lastActivityAt:i()};return delete a.endedAt,delete a.exitCode,a});return n&&this.appendEvent(t,"run_resumed",{reason:r}),n}setPinned(t,r){let n=this.update(t,s=>({...s,pinned:r,lastActivityAt:i()}));return n&&this.appendEvent(t,r?"run_pinned":"run_unpinned",{pinned:r}),n}appendEvent(t,r,n={}){let s=d(this.recordPath(t)),a=s?.eventsPath??u(this.runsDir,t,"events.jsonl");l(b(a),{recursive:!0});let o={schemaVersion:D,runId:t,type:r,timestamp:i(),payload:n};M(a,JSON.stringify(o)+`
-`,"utf8"),s&&this.update(t,c=>({...c,lastActivityAt:o.timestamp}))}readEvents(t){let r=this.get(t);return!r||!y(r.eventsPath)?[]:L(r.eventsPath,"utf8").split(/\r?\n/).map(n=>n.trim()).filter(Boolean).map(n=>{try{return JSON.parse(n)}catch{return null}}).filter(n=>n!==null)}delete(t){j(u(this.runsDir,t),{recursive:!0,force:!0})}refreshRecordStatus(t){if(et(t.status))return t;if(t.workerPid&&!tt(t.workerPid)){let r={...t,status:"failed",statusReason:"Worker process is no longer running and did not record a terminal status.",endedAt:t.endedAt??i(),updatedAt:i()};return this.write(r),r}return t}update(t,r){let n=d(this.recordPath(t));if(!n)return null;let s=r(n);return s.updatedAt=i(),this.write(s),s}write(t){let r=S(u(this.runDir(t.runId),"run.lock"),`run:${t.runId}`,m);try{Y(this.recordPath(t.runId),t)}finally{r.release()}}recordPath(t){return u(this.runsDir,R(P(t)),"run.json")}runDir(t){return u(this.runsDir,R(P(t)))}};export{E as AgentRunStore,S as acquireControlPlaneLock,nt as createAgentRunId,At as getAgentRunDir,Rt as getAgentRunStoreDir};
+import{randomUUID as Ee}from"crypto";import{existsSync as De,mkdirSync as b,readFileSync as xe,readdirSync as Ie,renameSync as Te,rmSync as Pe,writeFileSync as S}from"fs";import{homedir as be}from"os";import{basename as H,dirname as Oe,join as c,resolve as _e}from"path";var h="0.6.4";import{mkdirSync as ue,readFileSync as de,rmSync as $,writeFileSync as ce}from"fs";import{hostname as L}from"os";import{dirname as le}from"path";function pe(){return new Date().toISOString()}function ge(){return new Date(Date.now()-Math.floor(process.uptime()*1e3)).toISOString()}function F(n){try{return JSON.parse(de(n,"utf8"))}catch{return null}}function me(n){if(!n||n<=0)return!1;try{return process.kill(n,0),!0}catch{return!1}}function fe(n){return n.hostname!==L()?!0:me(n.pid)}function W(n,e){ue(le(n),{recursive:!0}),ce(n,JSON.stringify(e,null,2)+`
+`,{encoding:"utf8",flag:"wx"})}function he(n,e){let t=F(n);t?.pid!==e.pid||t.hostname!==e.hostname||$(n,{force:!0})}function k(n,e,t){let r=pe(),o={schemaVersion:1,name:e,pid:process.pid,hostname:L(),processStartedAt:ge(),version:t,acquiredAt:r,updatedAt:r};try{W(n,o)}catch(i){if(i.code!=="EEXIST")throw i;let a=F(n);if(a&&fe(a))throw new Error(`${e} is already locked by PID ${a.pid} on ${a.hostname}.`);$(n,{force:!0}),W(n,o)}return{record:o,release:()=>{he(n,o)}}}import{randomUUID as Re}from"crypto";import{appendFileSync as we,existsSync as ve,mkdirSync as j,readFileSync as ke}from"fs";import{basename as Ae,dirname as ye,join as Se}from"path";function J(n){return Ae(n).replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,96)}function q(n){return ve(n)?ke(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 A=class{constructor(e){this.runsDir=e;j(this.runsDir,{recursive:!0})}runsDir;pathFor(e){return Se(this.runsDir,J(e),"events.jsonl")}append(e,t,r={},o=new Date().toISOString()){let i=this.pathFor(e);j(ye(i),{recursive:!0});let s=k(`${i}.lock`,`events:${J(e)}`,h);try{let a=q(i).reduce((T,l,v)=>Math.max(T,l.sequence??v),-1)+1,p={schemaVersion:1,eventId:`event_${Re()}`,sequence:a,runId:e,type:t,timestamp:o,payload:r};return we(i,`${JSON.stringify(p)}
+`,"utf8"),p}finally{s.release()}}read(e){return q(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 Ce=1,Ue=c(be(),".xeno-agent"),Me=c(process.env.XENO_AGENT_HOME??Ue,"daemon"),_=c(Me,"runs");function d(){return new Date().toISOString()}function Ne(n=new Date){return n.toISOString().replace(/[^0-9]/g,"").slice(0,14)}function O(n){return n.replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,80)}function C(n){return _e(n)}function E(n){return C(n).toLowerCase()}function z(n,e){let t=E(n),r=E(e);return t===r||t.startsWith(`${r}\\`)||t.startsWith(`${r}/`)}function Ve(n,e){return!!(E(n.cwd)===E(e)||n.git?.root&&z(e,n.git.root)||n.git?.worktree&&z(e,n.git.worktree))}function We(n){return O(Buffer.from(C(n)).toString("base64url"))}function $e(){return{input:0,output:0,total:0}}function y(n){try{return JSON.parse(xe(n,"utf8"))}catch{return null}}function Le(n){return n instanceof Error&&/\balready locked by PID\b/.test(n.message)}function Fe(n,e){b(Oe(n),{recursive:!0});let t=`${n}.${process.pid}.${Date.now()}.tmp`;S(t,JSON.stringify(e,null,2)+`
+`,"utf8"),Te(t,n)}function je(n){if(!n||n<=0)return!1;try{return process.kill(n,0),!0}catch{return!1}}function Je(n){return n==="completed"||n==="failed"||n==="cancelled"||n==="interrupted"}function qe(n,e){return n.pinned!==e.pinned?n.pinned?-1:1:Date.parse(e.updatedAt)-Date.parse(n.updatedAt)}function bt(){return _}function Ot(n){return c(_,n)}function He(n=new Date){return`run_${Ne(n)}_${Ee().slice(0,8)}`}var D=class{constructor(e=_){this.runsDir=e;b(this.runsDir,{recursive:!0}),this.eventStore=new A(this.runsDir)}runsDir;eventStore;create(e){let t=He(),r=c(this.runsDir,t);b(r,{recursive:!0});let o=d(),i=c(r,"events.jsonl"),s={schemaVersion:Ce,runId:t,sessionId:t,rootRunId:t,cwd:C(e.cwd),workspaceId:We(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??h,createdAt:o,updatedAt:o,lastActivityAt:o,pinned:!!e.pinned,attachedClients:0,...e.cliVersion?{cliVersion:e.cliVersion}:{},...e.sdkVersion?{sdkVersion:e.sdkVersion}:{},stdoutPath:c(r,"stdout.log"),stderrPath:c(r,"stderr.log"),eventsPath:i,usage:$e(),children:[],tags:[]};return S(s.stdoutPath,"","utf8"),S(s.stderrPath,"","utf8"),S(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=y(this.recordPath(e));return t?this.refreshRecordStatus(t):null}list(e={}){if(!De(this.runsDir))return[];let t=Ie(this.runsDir,{withFileTypes:!0}).filter(r=>r.isDirectory()).map(r=>{try{return this.get(r.name)}catch(o){if(Le(o))return y(this.recordPath(r.name));throw o}}).filter(r=>r!==null).filter(r=>e.all||!e.cwd||Ve(r,e.cwd)).filter(r=>!e.status||e.status.includes(r.status)).sort(qe);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??d(),lastActivityAt:d()}))}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??d(),lastActivityAt:d()}))}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:d(),lastActivityAt:d()}))}markCancelled(e,t){return this.update(e,r=>({...r,status:"cancelled",statusReason:t,endedAt:d(),lastActivityAt:d()}))}markPaused(e,t="Paused by user."){let r=this.update(e,o=>({...o,status:"paused",statusReason:t,lastActivityAt:d()}));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:d()};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:d()}));return r&&this.appendEvent(e,t?"run_pinned":"run_unpinned",{pinned:t}),r}appendEvent(e,t,r={}){let o=y(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){Pe(c(this.runsDir,e),{recursive:!0,force:!0})}refreshRecordStatus(e){if(Je(e.status))return e;if(e.workerPid&&!je(e.workerPid)){let t={...e,status:"failed",statusReason:"Worker process is no longer running and did not record a terminal status.",endedAt:e.endedAt??d(),updatedAt:d()};return this.write(t),t}return e}update(e,t){let r=y(this.recordPath(e));if(!r)return null;let o=t(r);return o.updatedAt=d(),this.write(o),o}write(e){let t=k(c(this.runDir(e.runId),"run.lock"),`run:${e.runId}`,h);try{Fe(this.recordPath(e.runId),e)}finally{t.release()}}recordPath(e){return c(this.runsDir,O(H(e)),"run.json")}runDir(e){return c(this.runsDir,O(H(e)))}};function B(n){return n==="completed"||n==="failed"||n==="cancelled"||n==="interrupted"}var G=class{constructor(e={}){this.options=e;this.store=e.store??new D}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||B(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||B(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}};import{randomUUID as ze,timingSafeEqual as Be}from"crypto";var R=1;function Ge(n,e){if(!n)return!1;let t=Buffer.from(n),r=Buffer.from(e);return t.length===r.length&&Be(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!==R)return this.error(e.id,"PROTOCOL_MISMATCH",`Unsupported protocol version: ${e.protocolVersion}`);if(this.options.authToken&&!Ge(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:R,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:R,id:e,error:{code:t,message:r}}}},X=class{constructor(e,t={}){this.transport=e;this.options=t}transport;options;async request(e,t){let r={protocolVersion:R,id:`request_${ze()}`,method:e,params:t,...this.options.authToken?{authToken:this.options.authToken}:{}},o=await this.transport(r);if(o.protocolVersion!==R||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}};import{randomUUID as Z}from"crypto";import{appendFileSync as Qe,existsSync as Xe,mkdirSync as I,readFileSync as ee,readdirSync as Ze,renameSync as Ke,writeFileSync as Ye}from"fs";import{homedir as et}from"os";import{basename as tt,dirname as te,join as g}from"path";function x(n){return tt(n).replace(/[^A-Za-z0-9_.-]/g,"_").slice(0,96)}function U(n){try{return JSON.parse(ee(n,"utf8"))}catch{return null}}function K(n,e){I(te(n),{recursive:!0});let t=`${n}.${process.pid}.${Date.now()}.tmp`;Ye(t,`${JSON.stringify(e,null,2)}
+`,"utf8"),Ke(t,n)}var w=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(p=>o.has(p))).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}}},M=class{constructor(e=g(process.env.XENO_AGENT_HOME??g(et(),".xeno-agent"),"workflows")){this.rootDir=e;I(this.definitionsDir(),{recursive:!0}),I(this.runsDir(),{recursive:!0})}rootDir;saveDefinition(e){return new w().plan(e),K(g(this.definitionsDir(),`${x(e.id)}.json`),e),e}getDefinition(e){return U(g(this.definitionsDir(),`${x(e)}.json`))}listDefinitions(){return Ze(this.definitionsDir(),{withFileTypes:!0}).filter(e=>e.isFile()&&e.name.endsWith(".json")).map(e=>U(g(this.definitionsDir(),e.name))).filter(e=>e!==null)}createRun(e){new w().plan(e);let t=new Date().toISOString(),r={schemaVersion:1,runId:`workflow_run_${Z()}`,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 U(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_${Z()}`,runId:e,type:t,timestamp:new Date().toISOString(),...o?{nodeId:o}:{},payload:r},s=this.eventsPath(e);return I(te(s),{recursive:!0}),Qe(s,`${JSON.stringify(i)}
+`,"utf8"),i}readEvents(e){let t=this.eventsPath(e);return Xe(t)?ee(t,"utf8").split(/\r?\n/).filter(Boolean).flatMap(r=>{try{return[JSON.parse(r)]}catch{return[]}}):[]}writeRun(e){K(this.runPath(e.runId),e)}definitionsDir(){return g(this.rootDir,"definitions")}runsDir(){return g(this.rootDir,"runs")}runPath(e){return g(this.runsDir(),x(e),"run.json")}eventsPath(e){return g(this.runsDir(),x(e),"events.jsonl")}},Y=class{constructor(e=new M,t=new w){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 p=0;p<a.length;p+=i){let T=a.slice(p,p+i);await Promise.all(T.map(async l=>{let v=e.nodes.find(u=>u.id===l);if((v.dependsOn??[]).some(u=>this.store.getRun(o.runId)?.nodes[u]?.status!=="completed")||s&&e.failFast!==!1){this.store.updateRun(o.runId,u=>({...u,nodes:{...u.nodes,[l]:{status:"skipped",completedAt:new Date().toISOString()}}})),this.store.appendEvent(o.runId,"node_skipped",{},l);return}let P=new Date().toISOString();o=this.store.updateRun(o.runId,u=>({...u,nodes:{...u.nodes,[l]:{status:"running",startedAt:P}}})),this.store.appendEvent(o.runId,"node_started",{},l);try{let u=await t(v,{run:o,definition:e});this.store.updateRun(o.runId,f=>({...f,nodes:{...f.nodes,[l]:{status:"completed",startedAt:P,completedAt:new Date().toISOString(),output:u}}})),this.store.appendEvent(o.runId,"node_completed",{},l)}catch(u){s=!0;let f=u instanceof Error?u.message:String(u);this.store.updateRun(o.runId,V=>({...V,nodes:{...V.nodes,[l]:{status:"failed",startedAt:P,completedAt:new Date().toISOString(),error:f}}})),this.store.appendEvent(o.runId,"node_failed",{error:f},l)}}))}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}};import{randomUUID as rt}from"crypto";var re=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_${rt()}`,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}},ne=class{constructor(e){this.manager=e}manager;execute(e){return this.manager.start(e.sourceId,e.intervalMs)}},oe=class{constructor(e){this.manager=e}manager;execute(e){return this.manager.stop(e.sourceId)}};import{randomUUID as nt}from"crypto";import{appendFileSync as ot,existsSync as st,mkdirSync as it,readFileSync as at}from"fs";import{homedir as ut}from"os";import{dirname as dt,join as se}from"path";function m(n){return Number.isFinite(n)?Math.max(0,n??0):0}var N=class{totalsValue={inputTokens:0,outputTokens:0,totalTokens:0,cachedInputTokens:0,estimatedCostUsd:0,events:0};add(e){let t=m(e.inputTokens),r=m(e.outputTokens);return this.totalsValue.inputTokens+=t,this.totalsValue.outputTokens+=r,this.totalsValue.totalTokens+=t+r,this.totalsValue.cachedInputTokens+=m(e.cachedInputTokens),this.totalsValue.estimatedCostUsd+=m(e.estimatedCostUsd),this.totalsValue.events+=1,this}snapshot(){return{...this.totalsValue}}};function ct(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 ie=class{path;constructor(e=se(process.env.XENO_AGENT_HOME??se(ut(),".xeno-agent"),"usage","events.jsonl")){this.path=e,it(dt(e),{recursive:!0})}append(e){let t={...e,schemaVersion:1,eventId:`usage_${nt()}`,timestamp:e.timestamp??new Date().toISOString(),inputTokens:m(e.inputTokens),outputTokens:m(e.outputTokens),...e.cachedInputTokens!==void 0?{cachedInputTokens:m(e.cachedInputTokens)}:{},...e.estimatedCostUsd!==void 0?{estimatedCostUsd:m(e.estimatedCostUsd)}:{}};return ot(this.path,`${JSON.stringify(t)}
+`,"utf8"),t}query(e={}){return st(this.path)?at(this.path,"utf8").split(/\r?\n/).filter(Boolean).flatMap(t=>{try{let r=JSON.parse(t);return ct(r,e)?[r]:[]}catch{return[]}}):[]}summarize(e={}){let t=new N;for(let r of this.query(e))t.add(r);return t.snapshot()}},ae=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)}}};export{R as AGENT_DAEMON_PROTOCOL_VERSION,X as AgentDaemonClient,Q as AgentDaemonServer,A as AgentEventStore,G as AgentRunController,D as AgentRunStore,re as MonitorManager,oe as MonitorStopTool,ne as MonitorTool,ae as OtelExporter,N as UsageAccumulator,ie as UsageLedger,w as WorkflowPlanner,Y as WorkflowRuntime,M as WorkflowStore,k as acquireControlPlaneLock,He as createAgentRunId,Ot as getAgentRunDir,bt as getAgentRunStoreDir};

package/dist/control-plane/metafile-esm.json

@@ -0,0 +1 @@
+{"inputs":{"src/control-plane/types.ts":{"bytes":2358,"imports":[],"format":"esm"},"src/version.ts":{"bytes":36,"imports":[],"format":"esm"},"src/control-plane/lock.ts":{"bytes":2496,"imports":[{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true}],"format":"esm"},"src/control-plane/event-store.ts":{"bytes":2302,"imports":[{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"src/version.ts","kind":"import-statement","original":"../version.js"},{"path":"src/control-plane/lock.ts","kind":"import-statement","original":"./lock.js"}],"format":"esm"},"src/control-plane/run-store.ts":{"bytes":11654,"imports":[{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"src/version.ts","kind":"import-statement","original":"../version.js"},{"path":"src/control-plane/lock.ts","kind":"import-statement","original":"./lock.js"},{"path":"src/control-plane/event-store.ts","kind":"import-statement","original":"./event-store.js"}],"format":"esm"},"src/control-plane/controller.ts":{"bytes":4113,"imports":[{"path":"src/control-plane/run-store.ts","kind":"import-statement","original":"./run-store.js"}],"format":"esm"},"src/control-plane/daemon.ts":{"bytes":4922,"imports":[{"path":"crypto","kind":"import-statement","external":true}],"format":"esm"},"src/control-plane/workflow.ts":{"bytes":10140,"imports":[{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true}],"format":"esm"},"src/control-plane/monitor.ts":{"bytes":4008,"imports":[{"path":"crypto","kind":"import-statement","external":true}],"format":"esm"},"src/control-plane/usage.ts":{"bytes":5038,"imports":[{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true}],"format":"esm"},"src/control-plane/index.ts":{"bytes":272,"imports":[{"path":"src/control-plane/types.ts","kind":"import-statement","original":"./types.js"},{"path":"src/control-plane/run-store.ts","kind":"import-statement","original":"./run-store.js"},{"path":"src/control-plane/event-store.ts","kind":"import-statement","original":"./event-store.js"},{"path":"src/control-plane/controller.ts","kind":"import-statement","original":"./controller.js"},{"path":"src/control-plane/daemon.ts","kind":"import-statement","original":"./daemon.js"},{"path":"src/control-plane/workflow.ts","kind":"import-statement","original":"./workflow.js"},{"path":"src/control-plane/monitor.ts","kind":"import-statement","original":"./monitor.js"},{"path":"src/control-plane/usage.ts","kind":"import-statement","original":"./usage.js"},{"path":"src/control-plane/lock.ts","kind":"import-statement","original":"./lock.js"}],"format":"esm"}},"outputs":{"dist/control-plane/index.js":{"imports":[{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"crypto","kind":"import-statement","external":true},{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true},{"path":"crypto","kind":"import-statement","external":true},{"path":"crypto","kind":"import-statement","external":true},{"path":"fs","kind":"import-statement","external":true},{"path":"os","kind":"import-statement","external":true},{"path":"path","kind":"import-statement","external":true}],"exports":["AGENT_DAEMON_PROTOCOL_VERSION","AgentDaemonClient","AgentDaemonServer","AgentEventStore","AgentRunController","AgentRunStore","MonitorManager","MonitorStopTool","MonitorTool","OtelExporter","UsageAccumulator","UsageLedger","WorkflowPlanner","WorkflowRuntime","WorkflowStore","acquireControlPlaneLock","createAgentRunId","getAgentRunDir","getAgentRunStoreDir"],"entryPoint":"src/control-plane/index.ts","inputs":{"src/control-plane/index.ts":{"bytesInOutput":0},"src/control-plane/run-store.ts":{"bytesInOutput":5353},"src/version.ts":{"bytesInOutput":14},"src/control-plane/lock.ts":{"bytesInOutput":1026},"src/control-plane/event-store.ts":{"bytesInOutput":1042},"src/control-plane/controller.ts":{"bytesInOutput":1686},"src/control-plane/daemon.ts":{"bytesInOutput":1936},"src/control-plane/workflow.ts":{"bytesInOutput":4740},"src/control-plane/monitor.ts":{"bytesInOutput":1815},"src/control-plane/usage.ts":{"bytesInOutput":2263}},"bytes":20309}}}