use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::Arc;
use std::time::Duration;
use std::{io::Read, io::Write};
use futures::{SinkExt, StreamExt};
use incurs_codemode::{
ExecutionState as CodeExecutionState, ExecutionStatus as CodeExecutionStatus, RuntimeStore,
};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use sha2::{Digest, Sha256};
use tokio::net::{UnixListener, UnixStream};
use tokio::sync::RwLock;
use tokio_util::codec::{Framed, LengthDelimitedCodec};
use tokio_util::sync::CancellationToken;
use crate::code::{CodePool, capability_descriptors, execution_summary, external_connector};
use crate::environment::{
ScopedEnvironment, apply_environment, environment_view, selected_environment_scope,
validate_environment_name,
};
use crate::execution::ExecutionManager;
use crate::model::{
AgentSession, CausalEvent, ConnectorConfig, ExecutionSpec, ExecutionStatus,
InvocationScopeKind, Lease, LeaseOwnerKind, ProcessController, Recipe, RecipeAnnotations,
RecipeBundleV1, RecipeEvidenceRange, RecipeScopeKind, RecipeSuggestion, RecipeSuggestionStatus,
Reservation, ReservationKind, SecretRef, now_ms, valid_provider_name,
};
use crate::poll::PollManager;
use crate::process::{controller, port_owners};
use crate::recipe::{
portable_recipe, recipe_expired, recipe_generation, recipe_scope, validate_recipe_name,
};
use crate::run::RunManager;
use crate::store::{Store, runtime_dir, state_dir};
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DaemonStatus {
pub running: bool,
#[serde(default)]
pub version: Option<String>,
#[serde(default)]
pub execution_schema_version: Option<u32>,
pub pid: u32,
pub started_at: u64,
pub socket: String,
pub database: String,
pub active_executions: usize,
pub code_workers: usize,
}
#[derive(Debug, Serialize, Deserialize)]
struct RpcRequest {
id: String,
method: String,
params: Value,
#[serde(default = "default_controller")]
controller: ProcessController,
}
fn default_controller() -> ProcessController {
ProcessController::capture(false, None)
}
#[derive(Debug, Serialize, Deserialize)]
struct RpcResponse {
id: String,
result: Option<Value>,
error: Option<RpcError>,
}
#[derive(Debug, Serialize, Deserialize)]
struct RpcError {
code: String,
message: String,
}
#[derive(Debug)]
enum DaemonCallError {
Unavailable(String),
RequestFailed(String),
}
#[derive(Deserialize)]
struct StopParams {
id: String,
timeout_ms: u64,
}
#[derive(Deserialize)]
struct IdParams {
id: String,
}
#[derive(Deserialize)]
struct SignalParams {
id: String,
signal: String,
}
#[derive(Deserialize)]
struct InputParams {
id: String,
data: String,
}
#[derive(Deserialize)]
struct LogsParams {
id: String,
tail_bytes: usize,
}
#[derive(Deserialize)]
struct WaitParams {
id: String,
timeout_ms: Option<u64>,
}
#[derive(Deserialize)]
struct ExecutionStartParams {
spec: ExecutionSpec,
parent_id: Option<String>,
session_id: Option<String>,
}
#[derive(Deserialize)]
struct ExecutionListParams {
limit: usize,
cursor: Option<String>,
status: Option<ExecutionStatus>,
}
#[derive(Deserialize)]
struct PollIterationListParams {
id: String,
limit: usize,
cursor: Option<String>,
}
#[derive(Deserialize)]
struct PollIterationParams {
id: String,
iteration: String,
}
#[derive(Deserialize)]
struct SessionOpenParams {
actor: Option<String>,
labels: BTreeMap<String, String>,
ttl_ms: u64,
}
#[derive(Deserialize)]
struct RenewParams {
id: String,
ttl_ms: u64,
}
#[derive(Deserialize)]
struct ActiveParams {
active: bool,
}
#[derive(Deserialize)]
struct ReservationAcquireParams {
kind: String,
key: String,
lease_id: String,
ttl_ms: Option<u64>,
}
#[derive(Deserialize)]
struct EventQueryParams {
after: u64,
limit: usize,
}
#[derive(Deserialize)]
struct EventWatchParams {
after: u64,
limit: usize,
timeout_ms: u64,
}
#[derive(Deserialize)]
struct PinParams {
id: String,
pinned: bool,
}
#[derive(Deserialize)]
struct PruneParams {
max_age_ms: u64,
}
#[derive(Deserialize)]
struct ReceiptListParams {
limit: usize,
}
#[derive(Deserialize)]
struct CodeRunParams {
code: String,
timeout_ms: u64,
purpose: String,
}
#[derive(Deserialize)]
struct CodeParams {
code: String,
purpose: String,
}
#[derive(Deserialize)]
struct SearchParams {
query: String,
}
#[derive(Deserialize)]
struct ArtifactParams {
execution: String,
artifact: String,
}
#[derive(Serialize, Deserialize)]
struct EnvironmentMutationParams {
name: Option<String>,
value: Option<String>,
secret: Option<SecretRef>,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct EnvironmentLookupParams {
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipePutParams {
name: String,
description: String,
code: String,
input_schema: Option<Value>,
#[serde(default)]
output_schema: Option<Value>,
#[serde(default)]
dependencies: Vec<String>,
#[serde(default)]
required_env: Vec<String>,
#[serde(default)]
annotations: RecipeAnnotations,
#[serde(default)]
ttl_ms: Option<u64>,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeSuggestParams {
name: String,
description: String,
code: String,
input_schema: Option<Value>,
output_schema: Option<Value>,
#[serde(default)]
dependencies: Vec<String>,
#[serde(default)]
required_env: Vec<String>,
#[serde(default)]
annotations: RecipeAnnotations,
positive: Vec<String>,
#[serde(default)]
counterexample: Vec<String>,
rationale: String,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeSuggestionIdParams {
id: String,
}
#[derive(Serialize, Deserialize)]
struct RecipeAdoptParams {
id: String,
#[serde(default)]
ttl_ms: Option<u64>,
#[serde(default)]
replace: bool,
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeRunParams {
name: String,
timeout_ms: u64,
input: Value,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeLookupParams {
name: String,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeListParams {
#[serde(default)]
prefix: Option<String>,
#[serde(default)]
include_expired: bool,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeMutationParams {
#[serde(default)]
name: Option<String>,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecipeExportParams {
prefix: String,
file: String,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
replace: bool,
idempotency_key: String,
}
#[derive(Serialize, Deserialize)]
struct RecipeImportParams {
file: String,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
ttl_ms: Option<u64>,
#[serde(default)]
replace: bool,
idempotency_key: String,
}
pub struct Daemon {
store: Arc<Store>,
runs: RunManager,
executions: ExecutionManager,
polls: PollManager,
code: RwLock<CodePool>,
code_workers: usize,
shutdown: CancellationToken,
started_at: u64,
socket: PathBuf,
}
impl Daemon {
pub fn open_default() -> Result<Self, String> {
let store = Arc::new(Store::open_default()?);
let runs = RunManager::new(store.clone())?;
let code = CodePool::new(store.clone())?;
let code_workers = code.workers();
let executions = ExecutionManager::new(store.clone(), runs.clone());
let polls = PollManager::new(store.clone(), executions.clone());
Ok(Self {
executions,
polls,
runs,
code: RwLock::new(code),
code_workers,
store,
shutdown: CancellationToken::new(),
started_at: now_ms(),
socket: socket_path(),
})
}
pub async fn serve(self) -> Result<(), String> {
let runtime = runtime_dir();
std::fs::create_dir_all(&runtime).map_err(|error| error.to_string())?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&runtime, std::fs::Permissions::from_mode(0o700))
.map_err(|error| error.to_string())?;
}
let _lock = acquire_daemon_lock(&runtime)?;
self.runs.recover().await?;
self.executions.recover()?;
self.polls.recover()?;
if self.socket.exists() {
match UnixStream::connect(&self.socket).await {
Ok(_) => {
return Err(format!(
"An apoc daemon already owns {}",
self.socket.display()
));
}
Err(_) => {
std::fs::remove_file(&self.socket).map_err(|error| error.to_string())?;
}
}
}
let listener = UnixListener::bind(&self.socket).map_err(|error| error.to_string())?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&self.socket, std::fs::Permissions::from_mode(0o600))
.map_err(|error| error.to_string())?;
}
let daemon = Arc::new(self);
let mut cleanup = tokio::time::interval(Duration::from_secs(1));
cleanup.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
tokio::select! {
_ = daemon.shutdown.cancelled() => break,
_ = cleanup.tick() => {
let controller = default_controller();
let _ = daemon
.cleanup_expired_leases(Duration::from_secs(5), &controller)
.await;
let _ = daemon.store.prune_causal_payloads(
now_ms().saturating_sub(30 * 24 * 60 * 60 * 1_000),
);
let _ = daemon
.store
.prune_causal_payloads_to_size(10 * 1024 * 1024 * 1024);
}
accepted = listener.accept() => {
let (stream, _) = accepted.map_err(|error| error.to_string())?;
let daemon = Arc::clone(&daemon);
tokio::spawn(async move {
let _ = daemon.connection(stream).await;
});
}
}
}
let _ = std::fs::remove_file(&daemon.socket);
Ok(())
}
async fn connection(&self, stream: UnixStream) -> Result<(), String> {
let mut framed = Framed::new(stream, codec());
while let Some(frame) = framed.next().await {
let frame = frame.map_err(|error| error.to_string())?;
let request =
serde_json::from_slice::<RpcRequest>(&frame).map_err(|error| error.to_string())?;
let response = match self
.dispatch(&request.method, request.params, &request.controller)
.await
{
Ok(result) => RpcResponse {
id: request.id,
result: Some(result),
error: None,
},
Err(message) => RpcResponse {
id: request.id,
result: None,
error: Some(RpcError {
code: "DAEMON_REQUEST_FAILED".to_string(),
message,
}),
},
};
framed
.send(
serde_json::to_vec(&response)
.map_err(|error| error.to_string())?
.into(),
)
.await
.map_err(|error| error.to_string())?;
}
Ok(())
}
async fn dispatch(
&self,
method: &str,
params: Value,
controller: &ProcessController,
) -> Result<Value, String> {
match method {
"daemon.status" | "daemon.ping" => json(self.status()?),
"daemon.shutdown" => {
self.shutdown.cancel();
Ok(serde_json::json!({ "stopping": true }))
}
"execution.start" => {
let mut params = parse::<ExecutionStartParams>(params)?;
normalize_execution_workspace(&mut params.spec, controller)?;
let cwd = params.spec.workspace.cwd.clone();
apply_environment(&self.store, cwd.as_deref(), &mut params.spec)?;
params.parent_id = params.parent_id.or_else(|| controller.execution_id.clone());
if params.spec.owner_kind == crate::model::LeaseOwnerKind::Execution {
params.spec.owner_id = params.parent_id.clone();
}
if params.spec.owner_kind == crate::model::LeaseOwnerKind::Session {
params.spec.owner_id = params.session_id.clone();
}
let (execution, replayed) = self
.executions
.start_with_replay(
params.spec,
controller.clone(),
params.parent_id,
params.session_id,
)
.await?;
json(serde_json::json!({
"execution": execution,
"replayed": replayed,
"logs": null
}))
}
"execution.command" => {
let mut params = parse::<ExecutionStartParams>(params)?;
normalize_execution_workspace(&mut params.spec, controller)?;
let cwd = params.spec.workspace.cwd.clone();
apply_environment(&self.store, cwd.as_deref(), &mut params.spec)?;
params.parent_id = params.parent_id.or_else(|| controller.execution_id.clone());
if params.spec.owner_kind == crate::model::LeaseOwnerKind::Execution {
params.spec.owner_id = params.parent_id.clone();
}
if params.spec.owner_kind == crate::model::LeaseOwnerKind::Session {
params.spec.owner_id = params.session_id.clone();
}
let (execution, replayed) = self
.executions
.start_with_replay(
params.spec,
controller.clone(),
params.parent_id,
params.session_id,
)
.await?;
let execution = self.executions.wait(&execution.id, None).await?;
let logs = self.executions.logs(&execution.id, 32 * 1024)?;
json(serde_json::json!({
"execution": execution,
"replayed": replayed,
"logs": logs
}))
}
"execution.list" => {
let params = parse::<ExecutionListParams>(params)?;
json(self.executions.list_page(
params.limit,
params.cursor.as_deref(),
params.status,
)?)
}
"execution.get" => {
let params = parse::<IdParams>(params)?;
json(self.executions.get(¶ms.id)?)
}
"execution.wait" => {
let params = parse::<WaitParams>(params)?;
if self.store.get_execution_record(¶ms.id)?.is_some() {
json(
self.executions
.wait(¶ms.id, params.timeout_ms.map(Duration::from_millis))
.await?,
)
} else {
let state = self
.code
.read()
.await
.wait(¶ms.id, params.timeout_ms.map(Duration::from_millis))
.await?;
json(self.record_code_execution(&state, controller, None)?)
}
}
"execution.cancel" => {
let params = parse::<StopParams>(params)?;
if self.store.get_execution_record(¶ms.id)?.is_some() {
self.polls.notify_cancel(¶ms.id);
json(
self.executions
.cancel(
¶ms.id,
Duration::from_millis(params.timeout_ms),
controller,
)
.await?,
)
} else {
let state = self.code.read().await.cancel(params.id).await?;
json(self.record_code_execution(&state, controller, None)?)
}
}
"poll.start" | "poll.run" => {
let wait = method == "poll.run";
let mut params = parse::<ExecutionStartParams>(params)?;
normalize_execution_workspace(&mut params.spec, controller)?;
let cwd = params.spec.workspace.cwd.clone();
apply_environment(&self.store, cwd.as_deref(), &mut params.spec)?;
params.parent_id = params.parent_id.or_else(|| controller.execution_id.clone());
if params.spec.owner_kind == crate::model::LeaseOwnerKind::Execution {
params.spec.owner_id = params.parent_id.clone();
}
if params.spec.owner_kind == crate::model::LeaseOwnerKind::Session {
params.spec.owner_id = params.session_id.clone();
}
let (execution, replayed) = self
.polls
.start(
params.spec,
controller.clone(),
params.parent_id,
params.session_id,
)
.await?;
let execution = if wait {
self.executions.wait(&execution.id, None).await?
} else {
execution
};
json(serde_json::json!({
"execution": execution,
"replayed": replayed,
"logs": null
}))
}
"poll.iterations" => {
let params = parse::<PollIterationListParams>(params)?;
json(
self.polls
.iterations(¶ms.id, params.limit, params.cursor.as_deref())?,
)
}
"poll.iteration" => {
let params = parse::<PollIterationParams>(params)?;
json(self.polls.iteration(¶ms.id, ¶ms.iteration)?)
}
"execution.signal" => {
let params = parse::<SignalParams>(params)?;
json(
self.executions
.signal(¶ms.id, ¶ms.signal, controller)
.await?,
)
}
"execution.input" => {
let params = parse::<InputParams>(params)?;
json(
self.executions
.input(¶ms.id, params.data.as_bytes(), controller)
.await?,
)
}
"execution.logs" => {
let params = parse::<LogsParams>(params)?;
json(self.executions.logs(¶ms.id, params.tail_bytes)?)
}
"execution.attach" => {
let params = parse::<LogsParams>(params)?;
Ok(serde_json::json!({
"execution": self.executions.get(¶ms.id)?,
"logs": self.executions.logs(¶ms.id, params.tail_bytes)?,
"live_io": self.runs.is_active(¶ms.id).await
}))
}
"execution.remove" => {
let params = parse::<IdParams>(params)?;
let id = params.id;
Ok(serde_json::json!({
"id": id,
"removed": self.executions.remove(&id).await?
}))
}
"session.open" => {
let params = parse::<SessionOpenParams>(params)?;
if params.ttl_ms == 0 {
return Err("Session ttl_ms must be greater than zero".to_string());
}
let now = now_ms();
let session = AgentSession {
id: uuid::Uuid::now_v7().to_string(),
actor: params.actor.unwrap_or_else(|| controller.actor.clone()),
labels: params.labels,
created_at: now,
heartbeat_at: now,
expires_at: now.saturating_add(params.ttl_ms),
closed: false,
};
self.store.put_session(&session)?;
self.store.put_lease(&Lease {
id: session_lease_id(&session.id),
owner_kind: LeaseOwnerKind::Session,
owner_id: session.id.clone(),
resources: Vec::new(),
created_at: now,
renewed_at: now,
expires_at: Some(session.expires_at),
released: false,
})?;
self.lifecycle_event(
"session.opened",
&format!("session/{}", session.id),
controller,
None,
Some(session.id.clone()),
serde_json::json!({ "expires_at": session.expires_at }),
)?;
json(session)
}
"session.heartbeat" => {
let params = parse::<RenewParams>(params)?;
if params.ttl_ms == 0 {
return Err("Session ttl_ms must be greater than zero".to_string());
}
let mut session = self
.store
.get_session(¶ms.id)?
.ok_or_else(|| format!("Session \"{}\" not found", params.id))?;
if session.closed || session.expires_at <= now_ms() {
return Err(format!("Session \"{}\" is closed or expired", params.id));
}
session.heartbeat_at = now_ms();
session.expires_at = session.heartbeat_at.saturating_add(params.ttl_ms);
self.store.put_session(&session)?;
let mut lease = self
.store
.get_lease(&session_lease_id(&session.id))?
.ok_or_else(|| "Session root lease is missing".to_string())?;
lease.renewed_at = session.heartbeat_at;
lease.expires_at = Some(session.expires_at);
self.store.put_lease(&lease)?;
json(session)
}
"session.get" => {
let params = parse::<IdParams>(params)?;
json(
self.store
.get_session(¶ms.id)?
.ok_or_else(|| format!("Session \"{}\" not found", params.id))?,
)
}
"session.list" => {
let params = parse::<ActiveParams>(params)?;
json(self.store.list_sessions(params.active)?)
}
"session.close" => {
let params = parse::<StopParams>(params)?;
json(
self.close_session(
¶ms.id,
Duration::from_millis(params.timeout_ms),
controller,
)
.await?,
)
}
"lease.get" => {
let params = parse::<IdParams>(params)?;
json(
self.store
.get_lease(¶ms.id)?
.ok_or_else(|| format!("Lease \"{}\" not found", params.id))?,
)
}
"lease.list" => {
let params = parse::<ActiveParams>(params)?;
json(self.store.list_leases(params.active)?)
}
"lease.renew" => {
let params = parse::<RenewParams>(params)?;
if params.ttl_ms == 0 {
return Err("Lease ttl_ms must be greater than zero".to_string());
}
let mut lease = self
.store
.get_lease(¶ms.id)?
.ok_or_else(|| format!("Lease \"{}\" not found", params.id))?;
if lease.released {
return Err(format!("Lease \"{}\" is released", params.id));
}
lease.renewed_at = now_ms();
lease.expires_at = Some(lease.renewed_at.saturating_add(params.ttl_ms));
self.store.put_lease(&lease)?;
json(lease)
}
"lease.release" => {
let params = parse::<StopParams>(params)?;
let released = self
.release_lease(
¶ms.id,
Duration::from_millis(params.timeout_ms),
controller,
)
.await?;
Ok(serde_json::json!({ "id": params.id, "released": released }))
}
"lease.cleanup" => {
let params = parse::<StopParams>(params)?;
json(
self.cleanup_expired_leases(
Duration::from_millis(params.timeout_ms),
controller,
)
.await?,
)
}
"reservation.acquire" | "reservation.wait" => {
let params = parse::<ReservationAcquireParams>(params)?;
let wait = method == "reservation.wait";
json(self.acquire_reservation(params, wait).await?)
}
"reservation.get" => {
let params = parse::<IdParams>(params)?;
json(
self.store
.get_reservation(¶ms.id)?
.ok_or_else(|| format!("Reservation \"{}\" not found", params.id))?,
)
}
"reservation.list" => {
let params = parse::<ActiveParams>(params)?;
json(self.store.list_reservations(params.active)?)
}
"reservation.release" => {
let params = parse::<IdParams>(params)?;
let released = self.store.release_reservation(¶ms.id)?.is_some();
Ok(serde_json::json!({ "id": params.id, "released": released }))
}
"event.query" => {
let params = parse::<EventQueryParams>(params)?;
json(self.store.causal_events(params.after, params.limit)?)
}
"event.watch" => {
let params = parse::<EventWatchParams>(params)?;
let deadline =
tokio::time::Instant::now() + Duration::from_millis(params.timeout_ms);
loop {
let events = self.store.causal_events(params.after, params.limit)?;
if !events.is_empty() || tokio::time::Instant::now() >= deadline {
break json(events);
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
}
"event.payload" => {
let params = parse::<IdParams>(params)?;
let value = self
.store
.causal_payload(¶ms.id)?
.ok_or_else(|| format!("Payload \"{}\" is unavailable or pruned", params.id))?;
Ok(serde_json::json!({ "id": params.id, "value": value }))
}
"event.pin" => {
let params = parse::<PinParams>(params)?;
let updated = self.store.pin_causal_payload(¶ms.id, params.pinned)?;
Ok(serde_json::json!({
"id": params.id,
"pinned": params.pinned,
"updated": updated
}))
}
"event.prune-payloads" => {
let params = parse::<PruneParams>(params)?;
let before = now_ms().saturating_sub(params.max_age_ms);
let pruned = self.store.prune_causal_payloads(before)?;
Ok(serde_json::json!({ "pruned": pruned, "before": before }))
}
"receipt.get" => {
let params = parse::<IdParams>(params)?;
json(
self.store
.operation_receipt(¶ms.id)?
.ok_or_else(|| format!("Receipt \"{}\" not found", params.id))?,
)
}
"receipt.list" => {
let params = parse::<ReceiptListParams>(params)?;
json(self.store.operation_receipts(params.limit)?)
}
"code.run" => {
let params = parse::<CodeRunParams>(params)?;
let state = self
.code
.read()
.await
.run(
params.code,
controller.cwd.clone(),
Some(Duration::from_millis(params.timeout_ms)),
)
.await?;
self.record_code_execution(&state, controller, Some(¶ms.purpose))?;
Ok(execution_summary(&state))
}
"code.start" => {
let params = parse::<CodeParams>(params)?;
let state = self
.code
.read()
.await
.start(params.code, controller.cwd.clone())
.await?;
self.record_code_execution(&state, controller, Some(¶ms.purpose))?;
Ok(execution_summary(&state))
}
"code.get" => {
let params = parse::<IdParams>(params)?;
let state = self.code.read().await.get(params.id).await?;
self.record_code_execution(&state, controller, None)?;
json(state)
}
"code.cancel" => {
let params = parse::<IdParams>(params)?;
let state = self.code.read().await.cancel(params.id).await?;
self.record_code_execution(&state, controller, None)?;
json(state)
}
"code.search" => {
let params = parse::<SearchParams>(params)?;
json(self.code.read().await.search(params.query).await?)
}
"code.artifact" => {
let params = parse::<ArtifactParams>(params)?;
self.code
.read()
.await
.artifact(params.execution, params.artifact)
.await
}
"env.set" | "env.secret" | "env.unset" | "env.clear" => {
let params = parse::<EnvironmentMutationParams>(params)?;
let key = params
.idempotency_key
.as_deref()
.ok_or_else(|| format!("{method} requires idempotency_key"))?;
if params.global && params.cwd.is_some() {
return Err("--global and --cwd cannot be used together".to_string());
}
let selected_cwd = params.cwd.as_deref().or(controller.cwd.as_deref());
let (scope_kind, scope_key) =
selected_environment_scope(selected_cwd, params.global)?;
let fingerprint = recipe_request_fingerprint(method, ¶ms)?;
if let Some(output) = recipe_replay(&self.store, Some(key), method, &fingerprint)? {
return Ok(output);
}
if method == "env.clear" {
self.store
.delete_environment(scope_kind, scope_key.as_deref())?;
} else {
let name = params
.name
.as_deref()
.ok_or_else(|| "Environment name is required".to_string())?;
validate_environment_name(name)?;
let mut environment = self
.store
.get_environment(scope_kind, scope_key.as_deref())?
.unwrap_or_else(|| ScopedEnvironment::empty(scope_kind, scope_key.clone()));
match method {
"env.set" => {
let value = params.value.ok_or_else(|| {
"Environment literal value is required".to_string()
})?;
environment.secrets.remove(name);
environment.literals.insert(name.to_string(), value);
}
"env.secret" => {
let secret = params.secret.ok_or_else(|| {
"Environment secret reference is required".to_string()
})?;
if secret.provider != "env" {
return Err("Only env secret references are supported".to_string());
}
environment.literals.remove(name);
environment.secrets.insert(name.to_string(), secret);
}
"env.unset" => {
environment.literals.remove(name);
environment.secrets.remove(name);
}
_ => unreachable!(),
}
environment.refresh_generation();
if environment.literals.is_empty() && environment.secrets.is_empty() {
self.store
.delete_environment(scope_kind, scope_key.as_deref())?;
} else {
self.store.put_environment(&environment)?;
}
}
let output = serde_json::to_value(environment_view(&self.store, selected_cwd)?)
.map_err(|error| error.to_string())?;
recipe_record_replay(&self.store, Some(key), method, &fingerprint, &output)?;
Ok(output)
}
"env.list" | "env.doctor" => {
let params = parse::<EnvironmentLookupParams>(params)?;
if params.global && params.cwd.is_some() {
return Err("--global and --cwd cannot be used together".to_string());
}
let selected_cwd = params.cwd.as_deref().or(controller.cwd.as_deref());
if params.global {
json(environment_view(&self.store, None)?)
} else {
json(environment_view(&self.store, selected_cwd)?)
}
}
"recipe.suggest" => {
let params = parse::<RecipeSuggestParams>(params)?;
validate_recipe_name(¶ms.name)?;
if params.positive.len() < 2 {
return Err(
"Recipe suggestions require at least two positive ranges".to_string()
);
}
if params.rationale.trim().is_empty() {
return Err("Recipe suggestion rationale is required".to_string());
}
for dependency in ¶ms.dependencies {
validate_recipe_name(dependency)?;
}
for name in ¶ms.required_env {
validate_environment_name(name)?;
}
validate_recipe_schema(
params.input_schema.as_ref(),
"RECIPE_INPUT_SCHEMA_INVALID",
)?;
validate_recipe_schema(
params.output_schema.as_ref(),
"RECIPE_OUTPUT_SCHEMA_INVALID",
)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let now = now_ms();
let mut candidate_recipe = Recipe {
name: params.name,
description: params.description,
code: params.code,
input_schema: params.input_schema,
output_schema: params.output_schema,
dependencies: params.dependencies,
required_env: params.required_env,
annotations: params.annotations,
scope_kind,
scope_key: scope_key.clone(),
generation: String::new(),
expires_at: None,
last_used_at: None,
created_at: now,
updated_at: now,
origin_suggestion_id: None,
};
candidate_recipe.generation = recipe_generation(&candidate_recipe)?;
let positive_evidence = resolve_evidence_ranges(
&self.store,
¶ms.positive,
scope_kind,
scope_key.as_deref(),
)?;
let counterexamples = resolve_evidence_ranges(
&self.store,
¶ms.counterexample,
scope_kind,
scope_key.as_deref(),
)?;
let suggestion = RecipeSuggestion {
id: uuid::Uuid::now_v7().to_string(),
candidate: portable_recipe(&candidate_recipe),
positive_evidence,
counterexamples,
rationale: params.rationale,
scope_kind,
scope_key,
status: RecipeSuggestionStatus::Pending,
adopted_generation: None,
created_at: now,
adopted_at: None,
};
self.store.put_recipe_suggestion(&suggestion)?;
json(suggestion)
}
"recipe.suggestions" => json(self.store.list_recipe_suggestions()?),
"recipe.suggestion" => {
let params = parse::<RecipeSuggestionIdParams>(params)?;
json(
self.store
.get_recipe_suggestion(¶ms.id)?
.ok_or_else(|| format!("Recipe suggestion \"{}\" not found", params.id))?,
)
}
"recipe.adopt" => {
let params = parse::<RecipeAdoptParams>(params)?;
let key = params
.idempotency_key
.as_deref()
.ok_or_else(|| "recipe adopt requires idempotency_key".to_string())?;
if params.ttl_ms == Some(0) {
return Err("Recipe adoption ttl_ms must be greater than zero".to_string());
}
let fingerprint = recipe_request_fingerprint("recipe.adopt", ¶ms)?;
if let Some(output) =
recipe_replay(&self.store, Some(key), "recipe.adopt", &fingerprint)?
{
return Ok(output);
}
let mut suggestion = self
.store
.get_recipe_suggestion(¶ms.id)?
.ok_or_else(|| format!("Recipe suggestion \"{}\" not found", params.id))?;
let existing = self.store.get_recipe_definition(
suggestion.scope_kind,
suggestion.scope_key.as_deref(),
&suggestion.candidate.name,
)?;
if let Some(existing) = &existing
&& existing.generation != suggestion.candidate.generation
&& !params.replace
{
return Err(format!(
"RECIPE_ADOPT_CONFLICT: Recipe \"{}\" already has a different generation",
suggestion.candidate.name
));
}
let now = now_ms();
let mut recipe = Recipe {
name: suggestion.candidate.name.clone(),
description: suggestion.candidate.description.clone(),
code: suggestion.candidate.code.clone(),
input_schema: suggestion.candidate.input_schema.clone(),
output_schema: suggestion.candidate.output_schema.clone(),
dependencies: suggestion.candidate.dependencies.clone(),
required_env: suggestion.candidate.required_env.clone(),
annotations: suggestion.candidate.annotations.clone(),
scope_kind: suggestion.scope_kind,
scope_key: suggestion.scope_key.clone(),
generation: suggestion.candidate.generation.clone(),
expires_at: Some(
now.saturating_add(params.ttl_ms.unwrap_or(7 * 24 * 60 * 60 * 1000)),
),
last_used_at: existing.as_ref().and_then(|recipe| recipe.last_used_at),
created_at: existing.as_ref().map_or(now, |recipe| recipe.created_at),
updated_at: now,
origin_suggestion_id: Some(suggestion.id.clone()),
};
recipe.generation = recipe_generation(&recipe)?;
suggestion.status = RecipeSuggestionStatus::Adopted;
suggestion.adopted_generation = Some(recipe.generation.clone());
suggestion.adopted_at = Some(now);
self.store.adopt_recipe_suggestion(&recipe, &suggestion)?;
let output = serde_json::to_value(&recipe).map_err(|error| error.to_string())?;
recipe_record_replay(
&self.store,
Some(key),
"recipe.adopt",
&fingerprint,
&output,
)?;
Ok(output)
}
"recipe.put" => {
let params = parse::<RecipePutParams>(params)?;
validate_recipe_name(¶ms.name)?;
for dependency in ¶ms.dependencies {
validate_recipe_name(dependency)?;
}
if params.ttl_ms == Some(0) {
return Err("Recipe ttl_ms must be greater than zero".to_string());
}
validate_recipe_schema(
params.input_schema.as_ref(),
"RECIPE_INPUT_SCHEMA_INVALID",
)?;
validate_recipe_schema(
params.output_schema.as_ref(),
"RECIPE_OUTPUT_SCHEMA_INVALID",
)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let fingerprint = recipe_request_fingerprint("recipe.put", ¶ms)?;
if let Some(output) = recipe_replay(
&self.store,
params.idempotency_key.as_deref(),
"recipe.put",
&fingerprint,
)? {
return Ok(output);
}
let now = now_ms();
let created_at = self
.store
.get_recipe_definition(scope_kind, scope_key.as_deref(), ¶ms.name)?
.map(|recipe| recipe.created_at)
.unwrap_or(now);
let mut recipe = Recipe {
name: params.name,
description: params.description,
code: params.code,
input_schema: params.input_schema,
output_schema: params.output_schema,
dependencies: params.dependencies,
required_env: params.required_env,
annotations: params.annotations,
scope_kind,
scope_key,
generation: String::new(),
expires_at: params.ttl_ms.map(|ttl| now.saturating_add(ttl)),
last_used_at: None,
created_at,
updated_at: now,
origin_suggestion_id: None,
};
recipe.generation = recipe_generation(&recipe)?;
self.store.put_recipe_definition(&recipe)?;
let output = serde_json::to_value(&recipe).map_err(|error| error.to_string())?;
recipe_record_replay(
&self.store,
params.idempotency_key.as_deref(),
"recipe.put",
&fingerprint,
&output,
)?;
Ok(output)
}
"recipe.list" => {
let params = parse::<RecipeListParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let mut visible = BTreeMap::<String, Recipe>::new();
if scope_kind != RecipeScopeKind::Global {
for recipe in self.store.list_recipe_definitions(
scope_kind,
scope_key.as_deref(),
params.include_expired,
params.prefix.as_deref(),
)? {
visible.insert(recipe.name.clone(), recipe);
}
}
for recipe in self.store.list_recipe_definitions(
RecipeScopeKind::Global,
None,
params.include_expired,
params.prefix.as_deref(),
)? {
visible.entry(recipe.name.clone()).or_insert(recipe);
}
json(visible.into_values().collect::<Vec<_>>())
}
"recipe.get" => {
let params = parse::<RecipeLookupParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
json(resolve_visible_recipe(
&self.store,
scope_kind,
scope_key.as_deref(),
¶ms.name,
)?)
}
"recipe.remove" => {
let params = parse::<RecipeMutationParams>(params)?;
let name = params
.name
.as_deref()
.ok_or_else(|| "Recipe name is required".to_string())?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let fingerprint = recipe_request_fingerprint("recipe.remove", ¶ms)?;
if let Some(output) = recipe_replay(
&self.store,
params.idempotency_key.as_deref(),
"recipe.remove",
&fingerprint,
)? {
return Ok(output);
}
let output = serde_json::json!({
"id": name,
"removed": self.store.delete_recipe_definition(
scope_kind,
scope_key.as_deref(),
name,
)?
});
recipe_record_replay(
&self.store,
params.idempotency_key.as_deref(),
"recipe.remove",
&fingerprint,
&output,
)?;
Ok(output)
}
"recipe.pin" => {
let params = parse::<RecipeMutationParams>(params)?;
let key = params
.idempotency_key
.as_deref()
.ok_or_else(|| "recipe pin requires idempotency_key".to_string())?;
let name = params
.name
.as_deref()
.ok_or_else(|| "Recipe name is required".to_string())?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let fingerprint = recipe_request_fingerprint("recipe.pin", ¶ms)?;
if let Some(output) =
recipe_replay(&self.store, Some(key), "recipe.pin", &fingerprint)?
{
return Ok(output);
}
let mut recipe = self
.store
.get_recipe_definition(scope_kind, scope_key.as_deref(), name)?
.ok_or_else(|| format!("Recipe \"{name}\" not found in the selected scope"))?;
recipe.expires_at = None;
recipe.updated_at = now_ms();
self.store.put_recipe_definition(&recipe)?;
let output = serde_json::to_value(recipe).map_err(|error| error.to_string())?;
recipe_record_replay(&self.store, Some(key), "recipe.pin", &fingerprint, &output)?;
Ok(output)
}
"recipe.prune" => {
let params = parse::<RecipeMutationParams>(params)?;
let key = params
.idempotency_key
.as_deref()
.ok_or_else(|| "recipe prune requires idempotency_key".to_string())?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let fingerprint = recipe_request_fingerprint("recipe.prune", ¶ms)?;
if let Some(output) =
recipe_replay(&self.store, Some(key), "recipe.prune", &fingerprint)?
{
return Ok(output);
}
let removed = self
.store
.prune_recipe_definitions(scope_kind, scope_key.as_deref())?;
let output = serde_json::json!({ "removed": removed });
recipe_record_replay(
&self.store,
Some(key),
"recipe.prune",
&fingerprint,
&output,
)?;
Ok(output)
}
"recipe.export" => {
let params = parse::<RecipeExportParams>(params)?;
if params.prefix.is_empty() {
return Err("Recipe export prefix must not be empty".to_string());
}
let fingerprint = recipe_request_fingerprint("recipe.export", ¶ms)?;
if let Some(output) = recipe_replay(
&self.store,
Some(¶ms.idempotency_key),
"recipe.export",
&fingerprint,
)? {
return Ok(output);
}
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let mut roots = BTreeMap::<String, Recipe>::new();
if scope_kind != RecipeScopeKind::Global {
for recipe in self.store.list_recipe_definitions(
scope_kind,
scope_key.as_deref(),
false,
Some(¶ms.prefix),
)? {
roots.insert(recipe.name.clone(), recipe);
}
}
for recipe in self.store.list_recipe_definitions(
RecipeScopeKind::Global,
None,
false,
Some(¶ms.prefix),
)? {
roots.entry(recipe.name.clone()).or_insert(recipe);
}
if roots.is_empty() {
return Err(format!(
"RECIPE_EXPORT_EMPTY: no visible recipes match \"{}\"",
params.prefix
));
}
let mut definitions = BTreeMap::<String, Recipe>::new();
for root in roots.values() {
let graph = resolve_recipe_graph(
&self.store,
scope_kind,
scope_key.as_deref(),
&root.name,
)?;
definitions.extend(graph.recipes);
}
let bundle = RecipeBundleV1 {
schema_version: 1,
namespace: params.prefix.clone(),
recipes: definitions.values().map(portable_recipe).collect(),
};
let path = resolve_recipe_path(controller, ¶ms.file)?;
if path.exists() && !params.replace {
return Err(format!(
"RECIPE_EXPORT_EXISTS: {} already exists; pass --replace",
path.display()
));
}
let encoded =
serde_json::to_vec_pretty(&bundle).map_err(|error| error.to_string())?;
std::fs::write(&path, encoded).map_err(|error| error.to_string())?;
let output = serde_json::json!({
"file": path,
"namespace": bundle.namespace,
"recipes": bundle.recipes.len()
});
recipe_record_replay(
&self.store,
Some(¶ms.idempotency_key),
"recipe.export",
&fingerprint,
&output,
)?;
Ok(output)
}
"recipe.import" => {
let params = parse::<RecipeImportParams>(params)?;
if params.ttl_ms == Some(0) {
return Err("Recipe import ttl_ms must be greater than zero".to_string());
}
let fingerprint = recipe_request_fingerprint("recipe.import", ¶ms)?;
if let Some(output) = recipe_replay(
&self.store,
Some(¶ms.idempotency_key),
"recipe.import",
&fingerprint,
)? {
return Ok(output);
}
let path = resolve_recipe_path(controller, ¶ms.file)?;
let encoded = std::fs::read(&path).map_err(|error| error.to_string())?;
let bundle = serde_json::from_slice::<RecipeBundleV1>(&encoded)
.map_err(|error| format!("RECIPE_BUNDLE_INVALID: {error}"))?;
if bundle.schema_version != 1 {
return Err(format!(
"RECIPE_BUNDLE_VERSION: expected 1, found {}",
bundle.schema_version
));
}
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let names = bundle
.recipes
.iter()
.map(|recipe| recipe.name.clone())
.collect::<std::collections::BTreeSet<_>>();
if names.len() != bundle.recipes.len() {
return Err("RECIPE_BUNDLE_DUPLICATE: recipe names must be unique".to_string());
}
let now = now_ms();
let mut recipes = Vec::with_capacity(bundle.recipes.len());
for portable in bundle.recipes {
validate_recipe_name(&portable.name)?;
validate_recipe_schema(
portable.input_schema.as_ref(),
"RECIPE_INPUT_SCHEMA_INVALID",
)?;
validate_recipe_schema(
portable.output_schema.as_ref(),
"RECIPE_OUTPUT_SCHEMA_INVALID",
)?;
for dependency in &portable.dependencies {
if !names.contains(dependency) {
return Err(format!(
"RECIPE_BUNDLE_DEPENDENCY: {} requires missing {dependency}",
portable.name
));
}
}
if !params.replace
&& self
.store
.get_recipe_definition(
scope_kind,
scope_key.as_deref(),
&portable.name,
)?
.is_some()
{
return Err(format!(
"RECIPE_IMPORT_CONFLICT: Recipe \"{}\" already exists",
portable.name
));
}
let mut recipe = Recipe {
name: portable.name,
description: portable.description,
code: portable.code,
input_schema: portable.input_schema,
output_schema: portable.output_schema,
dependencies: portable.dependencies,
required_env: portable.required_env,
annotations: portable.annotations,
scope_kind,
scope_key: scope_key.clone(),
generation: String::new(),
expires_at: params.ttl_ms.map(|ttl| now.saturating_add(ttl)),
last_used_at: None,
created_at: now,
updated_at: now,
origin_suggestion_id: None,
};
recipe.generation = recipe_generation(&recipe)?;
if recipe.generation != portable.generation {
return Err(format!(
"RECIPE_BUNDLE_GENERATION: Recipe \"{}\" does not match its generation",
recipe.name
));
}
recipes.push(recipe);
}
self.store.put_recipe_definitions(&recipes)?;
let output = serde_json::json!({
"file": path,
"namespace": bundle.namespace,
"recipes": recipes.len()
});
recipe_record_replay(
&self.store,
Some(¶ms.idempotency_key),
"recipe.import",
&fingerprint,
&output,
)?;
Ok(output)
}
"recipe.run" => {
let params = parse::<RecipeRunParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let fingerprint = recipe_request_fingerprint("recipe.run", ¶ms)?;
if let Some(mut output) = recipe_replay(
&self.store,
params.idempotency_key.as_deref(),
"recipe.run",
&fingerprint,
)? {
if let Some(object) = output.as_object_mut() {
object.insert("replayed".to_string(), Value::Bool(true));
}
return Ok(output);
}
let graph = resolve_recipe_graph(
&self.store,
scope_kind,
scope_key.as_deref(),
¶ms.name,
)?;
validate_recipe_value(
graph.root.input_schema.as_ref(),
¶ms.input,
"RECIPE_INPUT_INVALID",
)?;
let recipe_cwd = params.cwd.as_deref().or(controller.cwd.as_deref());
let available = environment_view(&self.store, recipe_cwd)?;
for recipe in graph.recipes.values() {
for name in &recipe.required_env {
validate_environment_name(name)?;
let inherited = std::env::var_os(name).is_some();
let durable = available
.entries
.iter()
.any(|entry| entry.name == *name && entry.resolvable);
if !inherited && !durable {
return Err(format!("RECIPE_ENV_UNAVAILABLE: {name}"));
}
}
}
let code = composed_recipe_code(&graph, ¶ms.input)?;
let state = self
.code
.read()
.await
.run(
code,
recipe_cwd.map(ToString::to_string),
Some(Duration::from_millis(params.timeout_ms)),
)
.await?;
if state.status == CodeExecutionStatus::Completed {
validate_recipe_value(
graph.root.output_schema.as_ref(),
state.result.as_ref().unwrap_or(&Value::Null),
"RECIPE_OUTPUT_INVALID",
)?;
let mut root = graph.root.clone();
root.last_used_at = Some(now_ms());
self.store.put_recipe_definition(&root)?;
}
let mut output = execution_summary(&state);
if let Some(object) = output.as_object_mut() {
object.insert("recipe".to_string(), Value::String(graph.root.name.clone()));
object.insert(
"generation".to_string(),
Value::String(graph.root.generation.clone()),
);
object.insert(
"dependency_generations".to_string(),
serde_json::to_value(
graph
.recipes
.iter()
.filter(|(name, _)| *name != &graph.root.name)
.map(|(name, recipe)| (name.clone(), recipe.generation.clone()))
.collect::<BTreeMap<_, _>>(),
)
.map_err(|error| error.to_string())?,
);
object.insert("replayed".to_string(), Value::Bool(false));
}
recipe_record_replay(
&self.store,
params.idempotency_key.as_deref(),
"recipe.run",
&fingerprint,
&output,
)?;
Ok(output)
}
"provider.put" | "connector.put" => {
self.ensure_code_idle().await?;
let config = serde_json::from_value::<ConnectorConfig>(params)
.map_err(|error| error.to_string())?;
if !valid_provider_name(&config.name) {
return Err(format!(
"Provider \"{}\" is not a valid JavaScript namespace",
config.name
));
}
self.store.put_provider(
&config.name,
&serde_json::to_value(&config).map_err(|error| error.to_string())?,
)?;
self.reload_code().await?;
json(config)
}
"provider.list" | "connector.list" => json(
self.store
.list_providers()?
.into_iter()
.map(serde_json::from_value::<ConnectorConfig>)
.collect::<Result<Vec<_>, _>>()
.map_err(|error| error.to_string())?,
),
"provider.get" | "connector.get" => {
let params = parse::<IdParams>(params)?;
self.store
.get_provider(¶ms.id)?
.ok_or_else(|| format!("Provider \"{}\" not found", params.id))
}
"provider.doctor" => {
let params = parse::<IdParams>(params)?;
let value = self
.store
.get_provider(¶ms.id)?
.ok_or_else(|| format!("Provider \"{}\" not found", params.id))?;
let config = serde_json::from_value::<ConnectorConfig>(value)
.map_err(|error| error.to_string())?;
let connector = external_connector(config.clone(), self.store.clone())?;
let description = connector.describe().await?;
let capabilities = capability_descriptors(&config, &description);
Ok(serde_json::json!({
"provider": config.name,
"generation": config.generation,
"instructions": description.instructions,
"capabilities": capabilities
}))
}
"provider.refresh" => {
self.ensure_code_idle().await?;
let params = parse::<IdParams>(params)?;
let value = self
.store
.get_provider(¶ms.id)?
.ok_or_else(|| format!("Provider \"{}\" not found", params.id))?;
let mut config = serde_json::from_value::<ConnectorConfig>(value)
.map_err(|error| error.to_string())?;
let connector = external_connector(config.clone(), self.store.clone())?;
let description = connector.describe().await?;
let snapshot =
serde_json::to_vec(&description).map_err(|error| error.to_string())?;
config.generation = format!("sha256:{:x}", Sha256::digest(snapshot));
config.updated_at = now_ms();
let capabilities = capability_descriptors(&config, &description);
self.store.put_provider(
&config.name,
&serde_json::to_value(&config).map_err(|error| error.to_string())?,
)?;
self.reload_code().await?;
Ok(serde_json::json!({
"provider": config.name,
"generation": config.generation,
"capabilities": capabilities
}))
}
"provider.remove" | "connector.remove" => {
self.ensure_code_idle().await?;
let params = parse::<IdParams>(params)?;
let removed = self.store.delete_provider(¶ms.id)?;
self.reload_code().await?;
Ok(serde_json::json!({ "id": params.id, "removed": removed }))
}
_ => Err(format!("Unknown daemon method \"{method}\"")),
}
}
fn status(&self) -> Result<DaemonStatus, String> {
let active_executions = self
.executions
.list()?
.into_iter()
.filter(|execution| {
!matches!(
execution.status,
crate::model::ExecutionStatus::Completed
| crate::model::ExecutionStatus::Failed
| crate::model::ExecutionStatus::Canceled
)
})
.count();
Ok(DaemonStatus {
running: true,
version: Some(env!("CARGO_PKG_VERSION").to_string()),
execution_schema_version: Some(crate::model::SCHEMA_VERSION),
pid: std::process::id(),
started_at: self.started_at,
socket: self.socket.to_string_lossy().into_owned(),
database: self.runs.store().path().to_string_lossy().into_owned(),
active_executions,
code_workers: self.code_workers,
})
}
async fn close_session(
&self,
id: &str,
timeout: Duration,
controller: &ProcessController,
) -> Result<AgentSession, String> {
let mut session = self
.store
.get_session(id)?
.ok_or_else(|| format!("Session \"{id}\" not found"))?;
let executions = self
.store
.list_execution_records()?
.into_iter()
.filter(|execution| execution.session_id.as_deref() == Some(id))
.map(|execution| execution.id)
.collect::<Vec<_>>();
for execution in executions {
if self.runs.is_active(&execution).await {
let _ = self
.executions
.cancel(&execution, timeout, controller)
.await;
}
}
self.store.release_lease(&session_lease_id(id))?;
session.closed = true;
session.heartbeat_at = now_ms();
session.expires_at = session.heartbeat_at;
self.store.put_session(&session)?;
self.lifecycle_event(
"session.closed",
&format!("session/{id}"),
controller,
None,
Some(id.to_string()),
serde_json::json!({}),
)?;
Ok(session)
}
async fn release_lease(
&self,
id: &str,
timeout: Duration,
controller: &ProcessController,
) -> Result<bool, String> {
let Some(lease) = self.store.get_lease(id)? else {
return Ok(false);
};
if lease.released {
return Ok(true);
}
match lease.owner_kind {
LeaseOwnerKind::Execution => {
if self.runs.is_active(&lease.owner_id).await {
let _ = self
.executions
.cancel(&lease.owner_id, timeout, controller)
.await;
}
}
LeaseOwnerKind::Session => {
if self.store.get_session(&lease.owner_id)?.is_some() {
let _ = self
.close_session(&lease.owner_id, timeout, controller)
.await?;
}
}
LeaseOwnerKind::Persistent => {}
}
self.store.release_lease(id)?;
self.lifecycle_event(
"lease.released",
&format!("lease/{id}"),
controller,
None,
None,
serde_json::json!({ "owner_id": lease.owner_id }),
)?;
Ok(true)
}
async fn cleanup_expired_leases(
&self,
timeout: Duration,
controller: &ProcessController,
) -> Result<Vec<Lease>, String> {
let now = now_ms();
let expired = self
.store
.list_leases(false)?
.into_iter()
.filter(|lease| {
!lease.released && lease.expires_at.is_some_and(|expires_at| expires_at <= now)
})
.collect::<Vec<_>>();
let mut released = Vec::with_capacity(expired.len());
for lease in expired {
self.release_lease(&lease.id, timeout, controller).await?;
if let Some(lease) = self.store.get_lease(&lease.id)? {
released.push(lease);
}
}
Ok(released)
}
async fn acquire_reservation(
&self,
params: ReservationAcquireParams,
wait: bool,
) -> Result<Reservation, String> {
let lease = self
.store
.get_lease(¶ms.lease_id)?
.ok_or_else(|| format!("Lease \"{}\" not found", params.lease_id))?;
if lease.released
|| lease
.expires_at
.is_some_and(|expires_at| expires_at <= now_ms())
{
return Err(format!(
"Lease \"{}\" is released or expired",
params.lease_id
));
}
let kind = reservation_kind(¶ms.kind)?;
let key = reservation_key(kind, ¶ms.key)?;
let external_conflict = if kind == ReservationKind::Port {
let (protocol, port) = parse_reservation_port(&key)?;
!port_owners(port, Some(protocol))?.is_empty()
} else {
false
};
let reservation = Reservation {
id: uuid::Uuid::now_v7().to_string(),
kind,
key,
lease_id: params.lease_id,
created_at: now_ms(),
expires_at: params.ttl_ms.map(|ttl| now_ms().saturating_add(ttl)),
external_conflict,
released: false,
};
let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
loop {
match self.store.acquire_reservation(&reservation) {
Ok(reservation) => return Ok(reservation),
Err(error)
if wait
&& error.starts_with("RESERVATION_CONFLICT:")
&& tokio::time::Instant::now() < deadline =>
{
tokio::time::sleep(Duration::from_millis(25)).await;
}
Err(error) => return Err(error),
}
}
}
fn lifecycle_event(
&self,
kind: &str,
subject: &str,
controller: &ProcessController,
execution_id: Option<String>,
session_id: Option<String>,
details: Value,
) -> Result<CausalEvent, String> {
self.store.append_causal_event(CausalEvent {
sequence: 0,
id: uuid::Uuid::now_v7().to_string(),
at: now_ms(),
kind: kind.to_string(),
subject: subject.to_string(),
actor: controller.actor.clone(),
correlation_id: execution_id
.clone()
.or_else(|| session_id.clone())
.unwrap_or_else(|| controller.invocation_id.clone()),
causation_id: None,
execution_id,
session_id,
payload_id: None,
details,
})
}
fn record_code_execution(
&self,
state: &CodeExecutionState,
controller: &ProcessController,
purpose: Option<&str>,
) -> Result<crate::model::Execution, String> {
let previous = self.store.get_execution_record(&state.id)?;
let mut workspace = previous
.as_ref()
.map(|execution| execution.spec.workspace.clone())
.unwrap_or_else(|| crate::model::WorkspaceContext {
cwd: controller.cwd.clone(),
..crate::model::WorkspaceContext::default()
});
crate::execution::enrich_workspace(&mut workspace);
let status = code_status(state.status);
let pass = crate::model::ExecutionPass {
id: format!("{}/pass/1", state.id),
number: 1,
started_at: state.created_at,
completed_at: code_terminal(state.status).then_some(state.updated_at),
status,
error_code: state
.error
.as_ref()
.map(|_| "CODE_EXECUTION_FAILED".to_string()),
error: state.error.clone(),
};
let execution = crate::model::Execution {
id: state.id.clone(),
parent_id: previous
.as_ref()
.and_then(|execution| execution.parent_id.clone())
.or_else(|| controller.execution_id.clone()),
session_id: None,
spec: crate::model::ExecutionSpec {
schema_version: crate::model::SCHEMA_VERSION,
idempotency_key: None,
name: "code".to_string(),
purpose: previous
.as_ref()
.and_then(|execution| execution.spec.purpose.clone())
.or_else(|| purpose.map(ToString::to_string)),
labels: BTreeMap::new(),
program: crate::model::ExecutionProgram::Javascript {
source: state.code.clone(),
input: Value::Null,
},
workspace,
env: BTreeMap::new(),
secrets: BTreeMap::new(),
environment_generations: Vec::new(),
io: crate::model::IoMode::Pipes,
owner_kind: LeaseOwnerKind::Persistent,
owner_id: None,
expires_at: None,
retry: crate::model::RetryPolicy::default(),
budget: crate::model::ExecutionBudget::default(),
},
status,
passes: vec![pass],
attempts: Vec::new(),
created_at: state.created_at,
updated_at: state.updated_at,
last_progress_at: state.updated_at,
result: state.result.clone().or_else(|| {
state.error.as_ref().map(|error| {
serde_json::json!({
"error_code": "CODE_EXECUTION_FAILED",
"error": error
})
})
}),
};
self.store.put_execution_record(&execution)?;
let lease_id = format!("execution/{}", state.id);
if self.store.get_lease(&lease_id)?.is_none() {
self.store.put_lease(&Lease {
id: lease_id.clone(),
owner_kind: LeaseOwnerKind::Execution,
owner_id: state.id.clone(),
resources: Vec::new(),
created_at: state.created_at,
renewed_at: state.updated_at,
expires_at: None,
released: false,
})?;
}
if code_terminal(state.status) {
self.store.release_lease(&lease_id)?;
}
if previous.as_ref().map(|value| value.status) != Some(status) {
self.lifecycle_event(
&format!("execution.{}", model_status_name(status)),
&format!("execution/{}", state.id),
controller,
Some(state.id.clone()),
None,
serde_json::json!({ "runtime": "javascript" }),
)?;
}
Ok(execution)
}
async fn reload_code(&self) -> Result<(), String> {
*self.code.write().await = CodePool::new(self.store.clone())?;
Ok(())
}
async fn ensure_code_idle(&self) -> Result<(), String> {
if self.store.list_executions().await?.iter().any(|execution| {
matches!(
execution.status,
CodeExecutionStatus::Running | CodeExecutionStatus::Paused
)
}) {
return Err(
"External connectors cannot change while Code Mode executions are active"
.to_string(),
);
}
Ok(())
}
}
fn normalize_execution_workspace(
spec: &mut ExecutionSpec,
controller: &ProcessController,
) -> Result<(), String> {
let base = controller
.cwd
.as_deref()
.ok_or_else(|| "INVALID_WORKSPACE: caller working directory is unavailable".to_string())?;
let cwd = resolve_workspace_path(base, spec.workspace.cwd.as_deref())?;
spec.workspace.cwd = Some(cwd.clone());
if let crate::model::ExecutionProgram::Commands { commands, .. } = &mut spec.program {
for command in commands {
if command.cwd.is_some() {
command.cwd = Some(resolve_workspace_path(&cwd, command.cwd.as_deref())?);
}
}
}
Ok(())
}
fn resolve_workspace_path(base: &str, value: Option<&str>) -> Result<String, String> {
let path = match value {
Some(value) if Path::new(value).is_absolute() => PathBuf::from(value),
Some(value) => Path::new(base).join(value),
None => PathBuf::from(base),
};
let path = std::fs::canonicalize(&path).map_err(|error| {
format!(
"INVALID_WORKSPACE: could not resolve working directory {}: {error}",
path.display()
)
})?;
if !path.is_dir() {
return Err(format!(
"INVALID_WORKSPACE: working directory {} is not a directory",
path.display()
));
}
Ok(path.to_string_lossy().into_owned())
}
fn acquire_daemon_lock(runtime: &Path) -> Result<std::fs::File, String> {
try_acquire_lock(&runtime.join("apoc.lock"))?
.ok_or_else(|| format!("An apoc daemon already owns {}", runtime.display()))
}
fn try_acquire_lock(path: &Path) -> Result<Option<std::fs::File>, String> {
use std::os::fd::AsRawFd;
let file = std::fs::OpenOptions::new()
.create(true)
.truncate(false)
.read(true)
.write(true)
.open(path)
.map_err(|error| error.to_string())?;
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == -1 {
let error = std::io::Error::last_os_error();
if error.kind() == std::io::ErrorKind::WouldBlock {
return Ok(None);
}
return Err(format!("Failed to lock {}: {error}", path.display()));
}
Ok(Some(file))
}
#[derive(Debug, Clone, Default)]
pub struct DaemonClient;
impl DaemonClient {
pub async fn call<T: for<'de> Deserialize<'de>>(
&self,
method: &str,
params: impl Serialize,
) -> Result<T, String> {
let params = serde_json::to_value(params).map_err(|error| error.to_string())?;
let value = self.call_value(method, params, true).await?;
serde_json::from_value(value).map_err(|error| error.to_string())
}
pub async fn call_existing<T: for<'de> Deserialize<'de>>(
&self,
method: &str,
params: impl Serialize,
) -> Result<T, String> {
let params = serde_json::to_value(params).map_err(|error| error.to_string())?;
let value = self.call_value(method, params, false).await?;
serde_json::from_value(value).map_err(|error| error.to_string())
}
async fn call_value(
&self,
method: &str,
params: Value,
auto_start: bool,
) -> Result<Value, String> {
let method = method.to_string();
let controller = controller(false);
match tokio::task::spawn_blocking({
let method = method.clone();
let params = params.clone();
let controller = controller.clone();
move || call_sync(&method, params, controller)
})
.await
.map_err(|error| error.to_string())?
{
Ok(value) => Ok(value),
Err(DaemonCallError::Unavailable(error)) if auto_start => {
start_daemon().await?;
match tokio::task::spawn_blocking(move || call_sync(&method, params, controller))
.await
.map_err(|next| next.to_string())?
{
Ok(value) => Ok(value),
Err(DaemonCallError::Unavailable(next)) => {
Err(format!("Daemon did not start: {error}; {next}"))
}
Err(DaemonCallError::RequestFailed(next)) => Err(next),
}
}
Err(DaemonCallError::Unavailable(error)) => {
Err(format!("apoc daemon is not running: {error}"))
}
Err(DaemonCallError::RequestFailed(error)) => Err(error),
}
}
}
pub fn socket_path() -> PathBuf {
runtime_dir().join("apoc.sock")
}
async fn start_daemon() -> Result<(), String> {
let runtime = runtime_dir();
std::fs::create_dir_all(&runtime).map_err(|error| error.to_string())?;
let log_path = state_dir()?.join("daemon.log");
let startup = try_acquire_lock(&runtime.join("apoc.start.lock"))?;
if startup.is_some() {
if let Some(parent) = log_path.parent() {
std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
}
let stdout = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(&log_path)
.map_err(|error| error.to_string())?;
let stderr = stdout.try_clone().map_err(|error| error.to_string())?;
let executable = std::env::current_exe().map_err(|error| error.to_string())?;
let descriptors = inherited_descriptors()?;
let mut command = tokio::process::Command::new(executable);
command
.args([
"daemon",
"serve",
"--purpose",
"Serving the durable apoc daemon.",
])
.stdin(Stdio::null())
.stdout(Stdio::from(stdout))
.stderr(Stdio::from(stderr))
.kill_on_drop(false);
#[cfg(unix)]
unsafe {
command.pre_exec(move || {
for descriptor in &descriptors {
let flags = libc::fcntl(*descriptor, libc::F_GETFD);
if flags != -1
&& libc::fcntl(*descriptor, libc::F_SETFD, flags | libc::FD_CLOEXEC) == -1
{
return Err(std::io::Error::last_os_error());
}
}
if libc::setsid() == -1 {
return Err(std::io::Error::last_os_error());
}
Ok(())
});
}
command.spawn().map_err(|error| error.to_string())?;
}
let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
loop {
if UnixStream::connect(socket_path()).await.is_ok() {
return Ok(());
}
if tokio::time::Instant::now() >= deadline {
return Err(format!(
"Timed out starting apoc daemon; inspect {}",
log_path.display()
));
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
}
fn inherited_descriptors() -> Result<Vec<i32>, String> {
let directory = ["/proc/self/fd", "/dev/fd"]
.into_iter()
.find(|path| Path::new(path).exists())
.ok_or_else(|| "Cannot enumerate inherited file descriptors".to_string())?;
Ok(std::fs::read_dir(directory)
.map_err(|error| error.to_string())?
.filter_map(|entry| {
entry
.ok()?
.file_name()
.to_str()?
.parse::<i32>()
.ok()
.filter(|descriptor| *descriptor > 2)
})
.collect())
}
fn codec() -> LengthDelimitedCodec {
LengthDelimitedCodec::builder()
.max_frame_length(16 * 1024 * 1024)
.new_codec()
}
fn call_sync(
method: &str,
params: Value,
controller: ProcessController,
) -> Result<Value, DaemonCallError> {
call_sync_at(&socket_path(), method, params, controller)
}
fn call_sync_at(
socket: &Path,
method: &str,
params: Value,
controller: ProcessController,
) -> Result<Value, DaemonCallError> {
let mut stream = std::os::unix::net::UnixStream::connect(socket)
.map_err(|error| DaemonCallError::Unavailable(error.to_string()))?;
stream
.set_read_timeout(Some(Duration::from_secs(10 * 60)))
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
stream
.set_write_timeout(Some(Duration::from_secs(30)))
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
let id = uuid::Uuid::now_v7().to_string();
let payload = serde_json::to_vec(&RpcRequest {
id: id.clone(),
method: method.to_string(),
params,
controller,
})
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
if payload.len() > 16 * 1024 * 1024 {
return Err(DaemonCallError::RequestFailed(
"Daemon request exceeds 16 MiB".to_string(),
));
}
stream
.write_all(&(payload.len() as u32).to_be_bytes())
.and_then(|_| stream.write_all(&payload))
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
let mut length = [0_u8; 4];
stream
.read_exact(&mut length)
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
let length = u32::from_be_bytes(length) as usize;
if length > 16 * 1024 * 1024 {
return Err(DaemonCallError::RequestFailed(
"Daemon response exceeds 16 MiB".to_string(),
));
}
let mut payload = vec![0_u8; length];
stream
.read_exact(&mut payload)
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
let response = serde_json::from_slice::<RpcResponse>(&payload)
.map_err(|error| DaemonCallError::RequestFailed(error.to_string()))?;
if response.id != id {
return Err(DaemonCallError::RequestFailed(
"Daemon returned a mismatched RPC response".to_string(),
));
}
match (response.result, response.error) {
(Some(result), None) => Ok(result),
(_, Some(error)) => Err(DaemonCallError::RequestFailed(format!(
"{}: {}",
error.code, error.message
))),
_ => Err(DaemonCallError::RequestFailed(
"Daemon returned an invalid RPC response".to_string(),
)),
}
}
fn resolve_recipe_path(controller: &ProcessController, file: &str) -> Result<PathBuf, String> {
let path = PathBuf::from(file);
if path.is_absolute() {
return Ok(path);
}
controller
.cwd
.as_deref()
.map(|cwd| Path::new(cwd).join(path))
.ok_or_else(|| "A relative recipe file requires an invoking current directory".to_string())
}
fn selected_recipe_scope(
controller: &ProcessController,
global: bool,
cwd: Option<&str>,
) -> Result<(RecipeScopeKind, Option<String>), String> {
if global && cwd.is_some() {
return Err("--global and --cwd cannot be used together".to_string());
}
if global {
return Ok((RecipeScopeKind::Global, None));
}
let cwd = match cwd {
Some(cwd) if Path::new(cwd).is_absolute() => Some(cwd.to_string()),
Some(cwd) => controller
.cwd
.as_deref()
.map(|base| Path::new(base).join(cwd).to_string_lossy().into_owned()),
None => controller.cwd.clone(),
};
let (kind, key) = recipe_scope(cwd.as_deref());
if key.is_none() {
return Err("A local recipe requires an invoking current directory".to_string());
}
Ok((kind, key))
}
fn resolve_evidence_ranges(
store: &Store,
ranges: &[String],
scope_kind: RecipeScopeKind,
scope_key: Option<&str>,
) -> Result<Vec<RecipeEvidenceRange>, String> {
ranges
.iter()
.map(|range| {
let (start_id, end_id) = range
.split_once("..")
.ok_or_else(|| "Evidence ranges must use START_ID..END_ID".to_string())?;
if start_id.is_empty() || end_id.is_empty() {
return Err("Evidence range identifiers cannot be empty".to_string());
}
let (invocation_scope, invocation_key) = match scope_kind {
RecipeScopeKind::GitWorktree => (
InvocationScopeKind::GitWorktree,
scope_key.map(ToString::to_string),
),
RecipeScopeKind::Cwd => {
(InvocationScopeKind::Cwd, scope_key.map(ToString::to_string))
}
RecipeScopeKind::Global => {
let start = store
.get_invocation(start_id)?
.ok_or_else(|| format!("Evidence invocation \"{start_id}\" not found"))?;
(start.scope_kind, start.scope_key)
}
};
let invocation_ids = store.invocation_evidence_range(
start_id,
end_id,
invocation_scope,
invocation_key.as_deref(),
)?;
Ok(RecipeEvidenceRange {
start_id: start_id.to_string(),
end_id: end_id.to_string(),
invocation_ids,
})
})
.collect()
}
fn resolve_visible_recipe(
store: &Store,
scope_kind: RecipeScopeKind,
scope_key: Option<&str>,
name: &str,
) -> Result<Recipe, String> {
let now = now_ms();
if scope_kind != RecipeScopeKind::Global
&& let Some(recipe) = store.get_recipe_definition(scope_kind, scope_key, name)?
&& !recipe_expired(&recipe, now)
{
return Ok(recipe);
}
let recipe = store
.get_recipe_definition(RecipeScopeKind::Global, None, name)?
.ok_or_else(|| format!("RECIPE_NOT_FOUND: Recipe \"{name}\" not found"))?;
if recipe_expired(&recipe, now) {
return Err(format!("RECIPE_EXPIRED: Recipe \"{name}\" has expired"));
}
Ok(recipe)
}
struct ResolvedRecipeGraph {
root: Recipe,
recipes: BTreeMap<String, Recipe>,
}
fn resolve_recipe_graph(
store: &Store,
scope_kind: RecipeScopeKind,
scope_key: Option<&str>,
name: &str,
) -> Result<ResolvedRecipeGraph, String> {
let root = resolve_visible_recipe(store, scope_kind, scope_key, name)?;
let mut recipes = BTreeMap::new();
let mut stack = Vec::new();
resolve_recipe_dependencies(
store,
scope_kind,
scope_key,
&root,
&mut recipes,
&mut stack,
0,
)?;
Ok(ResolvedRecipeGraph {
root: root.clone(),
recipes,
})
}
fn resolve_recipe_dependencies(
store: &Store,
local_scope_kind: RecipeScopeKind,
local_scope_key: Option<&str>,
recipe: &Recipe,
recipes: &mut BTreeMap<String, Recipe>,
stack: &mut Vec<String>,
depth: usize,
) -> Result<(), String> {
if depth >= 16 {
return Err("RECIPE_DEPTH_LIMIT: dependency depth exceeds 16 recipes".to_string());
}
if let Some(index) = stack.iter().position(|name| name == &recipe.name) {
let mut cycle = stack[index..].to_vec();
cycle.push(recipe.name.clone());
return Err(format!("RECIPE_CYCLE: {}", cycle.join(" -> ")));
}
if recipes.contains_key(&recipe.name) {
return Ok(());
}
if recipes.len() >= 64 {
return Err("RECIPE_GRAPH_LIMIT: dependency graph exceeds 64 recipes".to_string());
}
stack.push(recipe.name.clone());
for dependency in &recipe.dependencies {
let dependency = if recipe.scope_kind == RecipeScopeKind::Global {
let dependency = store
.get_recipe_definition(RecipeScopeKind::Global, None, dependency)?
.ok_or_else(|| {
format!(
"RECIPE_DEPENDENCY_NOT_FOUND: Global recipe \"{}\" requires global recipe \"{dependency}\"",
recipe.name
)
})?;
if recipe_expired(&dependency, now_ms()) {
return Err(format!(
"RECIPE_DEPENDENCY_EXPIRED: Recipe \"{dependency}\" has expired",
dependency = dependency.name
));
}
dependency
} else {
resolve_visible_recipe(store, local_scope_kind, local_scope_key, dependency).map_err(
|error| {
format!(
"RECIPE_DEPENDENCY_NOT_FOUND: {} requires {dependency}: {error}",
recipe.name
)
},
)?
};
resolve_recipe_dependencies(
store,
local_scope_kind,
local_scope_key,
&dependency,
recipes,
stack,
depth + 1,
)?;
}
stack.pop();
recipes.insert(recipe.name.clone(), recipe.clone());
Ok(())
}
fn validate_recipe_value(schema: Option<&Value>, value: &Value, code: &str) -> Result<(), String> {
let Some(schema) = schema else {
return Ok(());
};
let validator = jsonschema::draft202012::new(schema)
.map_err(|error| format!("{code}: invalid schema: {error}"))?;
validator
.validate(value)
.map_err(|error| format!("{code}: {error}"))
}
fn validate_recipe_schema(schema: Option<&Value>, code: &str) -> Result<(), String> {
let Some(schema) = schema else {
return Ok(());
};
jsonschema::draft202012::new(schema)
.map(|_| ())
.map_err(|error| format!("{code}: {error}"))
}
fn composed_recipe_code(graph: &ResolvedRecipeGraph, input: &Value) -> Result<String, String> {
let mut code = String::from("const __apocRecipeFns = Object.create(null);\n");
for recipe in graph.recipes.values() {
code.push_str("__apocRecipeFns[");
code.push_str(&serde_json::to_string(&recipe.name).map_err(|error| error.to_string())?);
code.push_str("] = async function(input, recipes) {\n");
code.push_str(&recipe.code);
code.push_str("\n};\n");
}
code.push_str(
"const recipes = Object.freeze({ run: async (name, input) => {\n\
const recipe = __apocRecipeFns[name];\n\
if (!recipe) throw new Error(`RECIPE_UNDECLARED_DEPENDENCY: ${name}`);\n\
return await recipe(input, recipes);\n\
}});\n",
);
code.push_str("const input = ");
code.push_str(&serde_json::to_string(input).map_err(|error| error.to_string())?);
code.push_str(";\nreturn await __apocRecipeFns[");
code.push_str(&serde_json::to_string(&graph.root.name).map_err(|error| error.to_string())?);
code.push_str("](input, recipes);");
Ok(code)
}
#[derive(Serialize, Deserialize)]
struct RecipeReplay {
operation: String,
fingerprint: String,
output: Value,
}
fn recipe_request_fingerprint(operation: &str, params: &impl Serialize) -> Result<String, String> {
let encoded = serde_json::to_vec(&(operation, params)).map_err(|error| error.to_string())?;
Ok(format!("sha256:{:x}", Sha256::digest(encoded)))
}
fn recipe_replay(
store: &Store,
key: Option<&str>,
operation: &str,
fingerprint: &str,
) -> Result<Option<Value>, String> {
let Some(key) = key else {
return Ok(None);
};
let Some(replay) = store.get_receipt::<RecipeReplay>(&format!("recipe:{key}"))? else {
return Ok(None);
};
if replay.operation != operation || replay.fingerprint != fingerprint {
return Err(format!(
"RECIPE_IDEMPOTENCY_CONFLICT: key \"{key}\" was already used for a different request"
));
}
Ok(Some(replay.output))
}
fn recipe_record_replay(
store: &Store,
key: Option<&str>,
operation: &str,
fingerprint: &str,
output: &Value,
) -> Result<(), String> {
let Some(key) = key else {
return Ok(());
};
store.put_receipt(
&format!("recipe:{key}"),
"recipe_replay",
&RecipeReplay {
operation: operation.to_string(),
fingerprint: fingerprint.to_string(),
output: output.clone(),
},
)
}
fn parse<T: for<'de> Deserialize<'de>>(value: Value) -> Result<T, String> {
serde_json::from_value(value).map_err(|error| error.to_string())
}
fn json(value: impl Serialize) -> Result<Value, String> {
serde_json::to_value(value).map_err(|error| error.to_string())
}
fn session_lease_id(session_id: &str) -> String {
format!("session/{session_id}")
}
fn reservation_kind(value: &str) -> Result<ReservationKind, String> {
match value {
"port" => Ok(ReservationKind::Port),
"path" => Ok(ReservationKind::Path),
"process" => Ok(ReservationKind::Process),
"device" => Ok(ReservationKind::Device),
"custom" => Ok(ReservationKind::Custom),
_ => Err(format!("Unknown reservation kind \"{value}\"")),
}
}
fn reservation_key(kind: ReservationKind, value: &str) -> Result<String, String> {
if value.is_empty() {
return Err("Reservation keys cannot be empty".to_string());
}
match kind {
ReservationKind::Port => {
let value = value.to_ascii_lowercase();
let (protocol, port) = if let Some((protocol, port)) = value.split_once('/') {
if matches!(protocol, "tcp" | "udp") {
(protocol, port)
} else {
(port, protocol)
}
} else {
("tcp", value.as_str())
};
if !matches!(protocol, "tcp" | "udp") {
return Err("Port reservation protocol must be tcp or udp".to_string());
}
let port = port
.parse::<u16>()
.map_err(|_| format!("Invalid port reservation \"{value}\""))?;
Ok(format!("{protocol}/{port}"))
}
ReservationKind::Path => {
let path = PathBuf::from(value);
let path = if path.is_absolute() {
path
} else {
std::env::current_dir()
.map_err(|error| error.to_string())?
.join(path)
};
Ok(path.to_string_lossy().into_owned())
}
ReservationKind::Process => {
if !value.contains('@') {
return Err("Process reservations require an exact stable process key".to_string());
}
Ok(value.to_string())
}
ReservationKind::Device | ReservationKind::Custom => Ok(value.to_string()),
}
}
fn parse_reservation_port(value: &str) -> Result<(&str, u16), String> {
let (protocol, port) = value
.split_once('/')
.ok_or_else(|| format!("Invalid canonical port reservation \"{value}\""))?;
let port = port
.parse::<u16>()
.map_err(|_| format!("Invalid canonical port reservation \"{value}\""))?;
Ok((protocol, port))
}
fn code_status(status: CodeExecutionStatus) -> crate::model::ExecutionStatus {
match status {
CodeExecutionStatus::Running => crate::model::ExecutionStatus::Running,
CodeExecutionStatus::Paused => crate::model::ExecutionStatus::Interrupted,
CodeExecutionStatus::Completed => crate::model::ExecutionStatus::Completed,
CodeExecutionStatus::Cancelled => crate::model::ExecutionStatus::Canceled,
CodeExecutionStatus::Error
| CodeExecutionStatus::Rejected
| CodeExecutionStatus::RolledBack => crate::model::ExecutionStatus::Failed,
}
}
fn code_terminal(status: CodeExecutionStatus) -> bool {
matches!(
status,
CodeExecutionStatus::Completed
| CodeExecutionStatus::Error
| CodeExecutionStatus::Rejected
| CodeExecutionStatus::RolledBack
| CodeExecutionStatus::Cancelled
)
}
fn model_status_name(status: crate::model::ExecutionStatus) -> &'static str {
match status {
crate::model::ExecutionStatus::Queued => "queued",
crate::model::ExecutionStatus::Running => "running",
crate::model::ExecutionStatus::Stalled => "stalled",
crate::model::ExecutionStatus::Interrupted => "interrupted",
crate::model::ExecutionStatus::Completed => "completed",
crate::model::ExecutionStatus::Failed => "failed",
crate::model::ExecutionStatus::Canceled => "canceled",
}
}
#[cfg(test)]
mod tests {
use std::os::unix::net::UnixListener as StdUnixListener;
use std::thread;
use tempfile::tempdir;
use super::*;
#[test]
fn classifies_connection_failure_as_daemon_unavailability() {
let directory = tempdir().unwrap();
let result = call_sync_at(
&directory.path().join("missing.sock"),
"daemon.test",
Value::Null,
ProcessController::capture(true, None),
);
assert!(matches!(result, Err(DaemonCallError::Unavailable(_))));
}
#[test]
fn classifies_rpc_errors_as_request_failures() {
let directory = tempdir().unwrap();
let socket = directory.path().join("daemon.sock");
let listener = StdUnixListener::bind(&socket).unwrap();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let request = read_request(&mut stream);
write_response(
&mut stream,
RpcResponse {
id: request.id,
result: None,
error: Some(RpcError {
code: "TEST_FAILURE".to_string(),
message: "request was rejected".to_string(),
}),
},
);
});
let result = call_sync_at(
&socket,
"daemon.test",
Value::Null,
ProcessController::capture(true, None),
);
server.join().unwrap();
assert!(matches!(
result,
Err(DaemonCallError::RequestFailed(message))
if message == "TEST_FAILURE: request was rejected"
));
}
#[test]
fn classifies_post_send_disconnect_as_a_request_failure() {
let directory = tempdir().unwrap();
let socket = directory.path().join("daemon.sock");
let listener = StdUnixListener::bind(&socket).unwrap();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let _ = read_request(&mut stream);
});
let result = call_sync_at(
&socket,
"daemon.test",
Value::Null,
ProcessController::capture(true, None),
);
server.join().unwrap();
assert!(matches!(result, Err(DaemonCallError::RequestFailed(_))));
}
fn read_request(stream: &mut std::os::unix::net::UnixStream) -> RpcRequest {
let mut length = [0_u8; 4];
stream.read_exact(&mut length).unwrap();
let mut payload = vec![0_u8; u32::from_be_bytes(length) as usize];
stream.read_exact(&mut payload).unwrap();
serde_json::from_slice(&payload).unwrap()
}
fn write_response(stream: &mut std::os::unix::net::UnixStream, response: RpcResponse) {
let payload = serde_json::to_vec(&response).unwrap();
stream
.write_all(&(payload.len() as u32).to_be_bytes())
.unwrap();
stream.write_all(&payload).unwrap();
}
}