use std::collections::{BTreeMap, BTreeSet};
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_for_profile,
};
use crate::debugger::{
AppleAttachRequest, AppleAttachResult, AppleAttachStrategy, AppleDeviceProvider,
DebuggerAdapterKind, DebuggerDesiredState, DebuggerEvent, DebuggerManager,
DebuggerRecordingCorrelation, DebuggerRunResult, EXTENSION_SOCKET_NAME, ExtensionBridge,
ExtensionRuntimeStatus, ExtensionStatusView, ExtensionTab, RrBackend, RrExecutionResult,
RrProcessStatus, apple_attach_strategy_order, apple_dap_attach_arguments, apple_stable_target,
attach_legacy_artifact_summary, discover_targets, extension_doctor, install_extension_host,
legacy_debugger_status, migrate_legacy_debugger, query_legacy_debugger,
validate_legacy_debugger_artifacts,
};
use crate::environment::validate_environment_name;
use crate::execution::ExecutionManager;
use crate::hook::{Hook, HookDelivery, HookDeliveryStatus, hook_generation};
use crate::model::{
AgentSession, CausalEvent, ConnectorConfig, ExecutionArtifactRef, ExecutionBackendSpec,
ExecutionBudget, ExecutionExportSpec, ExecutionExportWhen, ExecutionProgram, ExecutionSpec,
ExecutionStatus, InvocationScopeKind, IoMode, IsolatedExecutionSpec, IsolatedNetworkPolicy,
IsolatedWorkspaceMode, Lease, LeaseOwnerKind, ProcessController, ProfileMode, ProfileSelection,
Recipe, RecipeAnnotations, RecipeBundleV1, RecipeEvidenceRange, RecipeScopeKind,
RecipeSuggestion, RecipeSuggestionStatus, Recording, RecordingDetail, RecordingParam,
RecordingStatus, RecordingStopOutput, RecordingTake, Reservation, ReservationKind, RetryPolicy,
SCHEMA_VERSION, SecretRef, TelemetryPolicy, WorkspaceContext, now_ms, valid_provider_name,
};
use crate::operation::{
AppleAppsOperation, AppleAttachOperation, AppleDevicesOperation, AppleResolveOperation,
DaemonOperation, DapAttachOperation, DapDisassembleOperation, DapLaunchOperation,
DapMemoryOperation, DapModulesOperation, DapRegistersOperation, DapRequestOperation,
DapSignalsOperation, DapStateOperation, DapThreadsOperation, DapWatchpointsOperation,
DebuggerBreakpointDeleteOperation, DebuggerBreakpointListOperation,
DebuggerBreakpointSetOperation, DebuggerBrowserClickOperation, DebuggerBrowserCookiesOperation,
DebuggerBrowserCoverageOperation, DebuggerBrowserDomOperation, DebuggerBrowserEmulateOperation,
DebuggerBrowserMockOperation, DebuggerBrowserNavigateOperation,
DebuggerBrowserNetworkBodyOperation, DebuggerBrowserNetworkOperation,
DebuggerBrowserPageEventsOperation, DebuggerBrowserPerformanceOperation,
DebuggerBrowserScreenshotOperation, DebuggerBrowserSelectOperation,
DebuggerBrowserStateOperation, DebuggerBrowserStorageOperation, DebuggerBrowserStylesOperation,
DebuggerBrowserThrottleOperation, DebuggerBrowserTypeOperation, DebuggerBrowserUnmockOperation,
DebuggerBrowserWebSocketsOperation, DebuggerCloseOperation, DebuggerConsoleOperation,
DebuggerContinueOperation, DebuggerEvaluateOperation, DebuggerEventsOperation,
DebuggerEvidenceTraceCursorOperation, DebuggerEvidenceTraceExportOperation,
DebuggerEvidenceTraceGcOperation, DebuggerEvidenceTraceImportOperation,
DebuggerEvidenceTraceJumpOperation, DebuggerEvidenceTraceListOperation,
DebuggerEvidenceTraceMoveOperation, DebuggerEvidenceTraceReplayOperation,
DebuggerEvidenceTraceShowOperation, DebuggerEvidenceTraceStartOperation,
DebuggerEvidenceTraceStopOperation, DebuggerEvidenceTraceUseOperation,
DebuggerExceptionsOperation, DebuggerExtensionAttachOperation,
DebuggerExtensionBridgeOperation, DebuggerExtensionCdpOperation,
DebuggerExtensionDetachOperation, DebuggerExtensionDoctorOperation,
DebuggerExtensionEvaluateOperation, DebuggerExtensionEventsOperation,
DebuggerExtensionInstallHostOperation, DebuggerExtensionObserveOperation,
DebuggerExtensionSnapshotOperation, DebuggerExtensionStatusOperation,
DebuggerExtensionTabsOperation, DebuggerExtensionUnobserveOperation, DebuggerFlowListOperation,
DebuggerFlowRecordOperation, DebuggerFlowRunOperation, DebuggerFlowShowOperation,
DebuggerFlowStopOperation, DebuggerHealthOperation, DebuggerLegacyImportOperation,
DebuggerLegacyQueryOperation, DebuggerLegacyStatusOperation, DebuggerListOperation,
DebuggerListenersOperation, DebuggerOpenOperation, DebuggerPauseOperation,
DebuggerPropertiesOperation, DebuggerPrototypesOperation, DebuggerReconnectOperation,
DebuggerRecordingAfterGetOperation, DebuggerRecordingAfterOperation,
DebuggerRecordingAftersOperation, DebuggerRecordingCaptureOperation,
DebuggerRecordingCapturesOperation, DebuggerRecordingCorrelateOperation,
DebuggerRecordingListOperation, DebuggerRecordingMarkOperation,
DebuggerRecordingMarksOperation, DebuggerRecordingReplayOperation,
DebuggerRecordingShootOperation, DebuggerRecordingStartOperation,
DebuggerRecordingStatusOperation, DebuggerRecordingStopOperation,
DebuggerRecordingTimelineOperation, DebuggerRecordingWhyOperation, DebuggerRestartOperation,
DebuggerResumeOperation, DebuggerRunOperation, DebuggerScopesOperation,
DebuggerScriptsOperation, DebuggerSelectOperation, DebuggerSelectedOperation,
DebuggerSourceOperation, DebuggerStackOperation, DebuggerStatusOperation,
DebuggerStepOperation, DebuggerTapAddOperation, DebuggerTapHitsOperation,
DebuggerTapListOperation, DebuggerTapRemoveOperation, DebuggerTargetsOperation,
DebuggerThisOperation, DebuggerTraceOperation, DebuggerVariablesOperation,
DebuggerWatchAddOperation, DebuggerWatchHitsOperation, DebuggerWatchListOperation,
DebuggerWatchRemoveOperation, ImageImportOperation, RecipeRecordingGetOperation,
RecipeRecordingStartOperation, RecipeRecordingStopOperation, RrImportOperation,
RrListOperation, RrProcessStatusOperation, RrRecordOperation, RrReplayOperation,
RrShowOperation,
};
use crate::poll::PollManager;
use crate::process::{ProcessManager, controller, port_owners};
use crate::profile::{
Profile, bind_profile, canonical_path, profile_view_by_name, profile_views, resolve_profile,
validate_profile_name,
};
use crate::provider_execution::RegisteredProviderExecutionGateway;
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};
mod gc;
pub use gc::{
DEFAULT_GC_INTERVAL_MS, DEFAULT_GC_RETENTION_DAYS, DEFAULT_IDLE_EXIT_MS,
DEFAULT_UNOWNED_LIFETIME_MS, GcCategory, GcConfig, GcCounts, GcReport, GcSpace, GcStatus,
UnownedPolicy, is_isolated,
};
#[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,
#[serde(default)]
pub gc: Option<GcStatus>,
}
#[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,
idempotency_key: Option<String>,
}
#[derive(Deserialize)]
struct TimeoutParams {
timeout_ms: u64,
}
#[derive(Deserialize)]
struct IdParams {
id: String,
}
#[derive(Serialize, Deserialize)]
struct ProviderPutParams {
config: ConnectorConfig,
idempotency_key: String,
}
#[derive(Serialize, Deserialize)]
struct ProviderMutationParams {
id: String,
idempotency_key: String,
}
#[derive(Serialize, Deserialize)]
struct ProviderRefreshParams {
id: String,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
profile: Option<String>,
idempotency_key: String,
}
#[derive(Deserialize)]
struct SignalParams {
id: String,
signal: String,
idempotency_key: String,
}
#[derive(Deserialize)]
struct InputParams {
id: String,
data: String,
idempotency_key: String,
}
#[derive(Deserialize)]
struct LogsParams {
id: String,
tail_bytes: usize,
#[serde(default)]
grep: Option<String>,
#[serde(default)]
context: Option<usize>,
#[serde(default)]
max_matches: Option<usize>,
#[serde(default)]
lines: Option<String>,
}
#[derive(Deserialize)]
struct WaitParams {
id: String,
timeout_ms: Option<u64>,
}
#[derive(Deserialize)]
struct ExecutionStartParams {
spec: ExecutionSpec,
parent_id: Option<String>,
session_id: Option<String>,
#[serde(default)]
profile: Option<String>,
#[serde(default)]
keep_alive: bool,
#[serde(default)]
lifetime_ms: Option<u64>,
}
fn validate_lifetime(keep_alive: bool, lifetime_ms: Option<u64>) -> Result<(), String> {
match (keep_alive, lifetime_ms) {
(_, Some(0)) => Err("lifetime_ms must be greater than zero".to_string()),
(true, Some(_)) => Err("keep_alive and lifetime_ms cannot be combined".to_string()),
_ => Ok(()),
}
}
#[derive(Deserialize)]
struct IsolationMutationParams {
idempotency_key: String,
#[serde(default)]
arguments: Value,
}
#[derive(Deserialize)]
struct TelemetryStartParams {
id: String,
interval_ms: u64,
max_bytes: u64,
idempotency_key: String,
}
#[derive(Deserialize)]
struct TelemetryStopParams {
id: String,
idempotency_key: String,
}
#[derive(Deserialize)]
struct TelemetryGetParams {
id: String,
#[serde(default)]
grep: Option<String>,
#[serde(default)]
context: Option<usize>,
#[serde(default)]
max_matches: Option<usize>,
#[serde(default)]
lines: Option<String>,
}
#[derive(Deserialize)]
struct ExecutionListParams {
limit: usize,
cursor: Option<String>,
status: Option<ExecutionStatus>,
error_code: Option<String>,
parent: Option<String>,
}
#[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 CodeWaitParams {
id: String,
timeout_ms: u64,
}
#[derive(Deserialize)]
struct CodeRunParams {
code: String,
timeout_ms: u64,
purpose: String,
#[serde(default)]
profile: Option<String>,
#[serde(default)]
telemetry: TelemetryPolicy,
#[serde(default)]
idempotency_key: Option<String>,
}
#[derive(Deserialize)]
struct CodeParams {
code: String,
purpose: String,
#[serde(default)]
profile: Option<String>,
#[serde(default)]
telemetry: TelemetryPolicy,
#[serde(default)]
idempotency_key: Option<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>,
#[serde(default)]
profile: Option<String>,
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct EnvironmentLookupParams {
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
profile: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct ProfileMutationParams {
#[serde(default)]
name: Option<String>,
#[serde(default)]
path: Option<String>,
#[serde(default)]
clear: bool,
idempotency_key: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct ProfileLookupParams {
#[serde(default)]
name: Option<String>,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
profile: Option<String>,
}
#[derive(Deserialize)]
struct ProviderLookupParams {
id: String,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
profile: 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)]
profile: 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 HookPutParams {
name: String,
command: String,
#[serde(default)]
on_start: Option<String>,
#[serde(default)]
on_success: Option<String>,
#[serde(default)]
on_failure: Option<String>,
#[serde(default = "default_true")]
enabled: bool,
#[serde(default = "default_hook_attempts")]
max_attempts: u32,
#[serde(default = "default_hook_timeout_ms")]
timeout_ms: u64,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct HookLookupParams {
name: String,
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct HookScopeParams {
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct HookDeliveryListParams {
#[serde(default)]
hook: Option<String>,
#[serde(default)]
status: Option<String>,
}
fn default_true() -> bool {
true
}
fn default_hook_attempts() -> u32 {
3
}
fn default_hook_timeout_ms() -> u64 {
300_000
}
#[derive(Serialize, Deserialize)]
struct RecordingScopeParams {
#[serde(default)]
global: bool,
#[serde(default)]
cwd: Option<String>,
}
#[derive(Serialize, Deserialize)]
struct RecordingParamParams {
assignment: String,
#[serde(default)]
json: bool,
#[serde(flatten)]
scope: RecordingScopeParams,
}
#[derive(Serialize, Deserialize)]
struct RecordingLiteralParams {
path: String,
#[serde(flatten)]
scope: RecordingScopeParams,
}
#[derive(Serialize, Deserialize)]
struct RecordingMutationParams {
#[serde(flatten)]
scope: RecordingScopeParams,
idempotency_key: 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,
isolation: Arc<RegisteredProviderExecutionGateway>,
apple_device: AppleDeviceProvider,
debugger: DebuggerManager,
extension_bridge: ExtensionBridge,
polls: PollManager,
code: RwLock<CodePool>,
dispatch: DispatchSlot,
gate: Arc<DeciderGate>,
runtime_dir: PathBuf,
_state_lock: std::fs::File,
code_workers: usize,
shutdown: CancellationToken,
started_at: u64,
socket: PathBuf,
state_dir: PathBuf,
isolated: bool,
idle_exit_ms: u64,
gc_config: GcConfig,
gc_status: std::sync::Mutex<GcStatus>,
gc_lock: tokio::sync::Mutex<()>,
activity: gc::Activity,
}
pub(crate) struct DeciderGate {
store: Arc<Store>,
dispatch: DispatchSlot,
active: std::sync::atomic::AtomicBool,
}
impl DeciderGate {
fn new(store: Arc<Store>, dispatch: DispatchSlot) -> Result<Self, String> {
let gate = Self {
store,
dispatch,
active: std::sync::atomic::AtomicBool::new(false),
};
gate.refresh()?;
Ok(gate)
}
fn refresh(&self) -> Result<(), String> {
let active = self
.store
.list_deciders()?
.iter()
.any(|decider| decider.enabled);
self.active
.store(active, std::sync::atomic::Ordering::Release);
Ok(())
}
}
#[async_trait::async_trait]
impl crate::intent::IntentGate for DeciderGate {
fn active(&self) -> bool {
self.active.load(std::sync::atomic::Ordering::Acquire)
}
async fn offer(&self, intent: crate::intent::Intent) -> Result<(), String> {
let deciders = self
.store
.list_deciders()?
.into_iter()
.filter(|decider| decider.applies_to(&intent.verb))
.collect::<Vec<_>>();
if deciders.is_empty() {
return Ok(());
}
let answers = match self.dispatch.current() {
Some((daemon, _)) => {
futures::future::join_all(
deciders
.iter()
.map(|decider| daemon.ask_decider(decider, &intent)),
)
.await
}
None => deciders
.iter()
.map(|decider| crate::intent::DeciderAnswer {
decider: decider.name.clone(),
decision: None,
reason: String::new(),
unavailable: Some("the core was not serving yet".to_string()),
elapsed_ms: 0,
})
.collect(),
};
let (proceeded, state, reason) = crate::intent::combine(&answers, &deciders);
self.store.put_intent_record(&crate::intent::IntentRecord {
intent,
proceeded,
state,
reason: reason.clone(),
answers,
})?;
if proceeded { Ok(()) } else { Err(reason) }
}
}
#[derive(Deserialize)]
struct DeciderPutParams {
name: String,
program: String,
#[serde(default)]
verbs: Vec<String>,
#[serde(default = "default_decider_timeout_ms")]
timeout_ms: u64,
on_unavailable: crate::intent::OnUnavailable,
#[serde(default = "default_true")]
enabled: bool,
}
fn default_decider_timeout_ms() -> u64 {
2_000
}
#[derive(Deserialize)]
struct DeciderNameParams {
name: String,
}
#[derive(Deserialize)]
struct IntentListParams {
limit: Option<usize>,
}
#[derive(Debug, Clone)]
pub struct CoreConfig {
pub state_dir: PathBuf,
pub runtime_dir: PathBuf,
}
impl CoreConfig {
pub fn new(state_dir: impl Into<PathBuf>) -> Self {
let state_dir = state_dir.into();
let runtime_dir = state_dir.join("runtime");
Self {
state_dir,
runtime_dir,
}
}
pub fn from_env() -> Result<Self, String> {
Ok(Self {
state_dir: crate::store::state_dir()?,
runtime_dir: runtime_dir(),
})
}
}
fn acquire_state_lock(state_dir: &Path) -> Result<std::fs::File, String> {
std::fs::create_dir_all(state_dir).map_err(|error| error.to_string())?;
try_acquire_lock(&state_dir.join("owner.lock"))?.ok_or_else(|| {
format!(
"STATE_ROOT_BUSY: another apoc core owns {}; connect to its daemon instead",
state_dir.display()
)
})
}
impl Daemon {
pub fn open_default() -> Result<Self, String> {
Self::open(&CoreConfig::from_env()?)
}
pub fn open(config: &CoreConfig) -> Result<Self, String> {
let state_lock = acquire_state_lock(&config.state_dir)?;
let store = Arc::new(Store::open(config.state_dir.join("apoc.sqlite3"))?);
let runs = RunManager::new(store.clone())?;
let dispatch = DispatchSlot::default();
let code = CodePool::with_dispatch(store.clone(), dispatch.clone())?;
let code_workers = code.workers();
let isolation = Arc::new(RegisteredProviderExecutionGateway::new(store.clone()));
let gate = Arc::new(DeciderGate::new(store.clone(), dispatch.clone())?);
let executions =
ExecutionManager::with_provider(store.clone(), runs.clone(), isolation.clone())
.with_gate(gate.clone());
let polls = PollManager::new(store.clone(), executions.clone());
let gc_config = GcConfig::from_env();
let started_at = now_ms();
Ok(Self {
executions,
isolation,
apple_device: AppleDeviceProvider::default(),
debugger: DebuggerManager::new(store.clone()),
extension_bridge: ExtensionBridge::default(),
polls,
runs,
code: RwLock::new(code),
dispatch,
gate,
code_workers,
store,
shutdown: CancellationToken::new(),
started_at,
socket: config.runtime_dir.join("apoc.sock"),
runtime_dir: config.runtime_dir.clone(),
_state_lock: state_lock,
state_dir: config.state_dir.clone(),
isolated: is_isolated(config),
idle_exit_ms: gc::idle_exit_ms_from_env(),
gc_status: std::sync::Mutex::new(GcStatus {
interval_ms: gc_config.interval_ms,
retention_days: gc_config.retention_days,
unowned_policy: gc_config.unowned,
..GcStatus::default()
}),
gc_config,
gc_lock: tokio::sync::Mutex::new(()),
activity: gc::Activity::new(started_at),
})
}
pub async fn serve(self) -> Result<(), String> {
let runtime = self.runtime_dir.clone();
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.recover_owned_state().await?;
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())?;
let bound_socket = socket_identity(&self.socket);
let extension_socket = runtime.join(EXTENSION_SOCKET_NAME);
if extension_socket.exists() {
std::fs::remove_file(&extension_socket).map_err(|error| error.to_string())?;
}
let extension_listener =
UnixListener::bind(&extension_socket).map_err(|error| error.to_string())?;
let bound_extension_socket = socket_identity(&extension_socket);
#[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())?;
std::fs::set_permissions(&extension_socket, std::fs::Permissions::from_mode(0o600))
.map_err(|error| error.to_string())?;
}
let daemon = Arc::new(self);
let _serving = daemon.dispatch.serve(&daemon);
let maintenance = Daemon::spawn_maintenance(&daemon);
let collector = Daemon::spawn_gc(&daemon);
let idle_exit = Daemon::spawn_idle_exit(&daemon);
loop {
tokio::select! {
_ = daemon.shutdown.cancelled() => break,
accepted = listener.accept() => {
let (stream, _) = accepted.map_err(|error| error.to_string())?;
let daemon = Arc::clone(&daemon);
let connected = daemon.activity.connection();
tokio::spawn(async move {
let _connected = connected;
if let Err(error) = daemon.connection(stream).await {
eprintln!("[apoc] rpc connection ended: {error}");
}
});
}
accepted = extension_listener.accept() => {
let (stream, _) = accepted.map_err(|error| error.to_string())?;
let bridge = daemon.extension_bridge.clone();
tokio::spawn(async move {
let _ = bridge.serve_connection(stream).await;
});
}
}
}
maintenance.abort();
for task in [collector, idle_exit].into_iter().flatten() {
task.abort();
}
remove_owned_socket(&daemon.socket, bound_socket);
remove_owned_socket(&extension_socket, bound_extension_socket);
Ok(())
}
async fn ask_decider(
&self,
decider: &crate::intent::Decider,
intent: &crate::intent::Intent,
) -> crate::intent::DeciderAnswer {
let started = std::time::Instant::now();
let unavailable = |why: String| crate::intent::DeciderAnswer {
decider: decider.name.clone(),
decision: None,
reason: String::new(),
unavailable: Some(why),
elapsed_ms: started.elapsed().as_millis() as u64,
};
let payload = match serde_json::to_string(intent) {
Ok(payload) => payload,
Err(error) => return unavailable(format!("could not encode the intent: {error}")),
};
let source = format!(
"const intent = Object.freeze({payload});\n{}",
decider.program
);
let origin = crate::code::RequestOrigin {
cwd: intent.lineage.cwd.clone(),
verbosity: Some(crate::model::Verbosity::Trace.as_str().to_string()),
profile_selection: None,
hook_depth: 0,
decider_depth: 1,
..Default::default()
};
let limit = Duration::from_millis(decider.timeout_ms);
let state = {
let pool = self.code.read().await;
pool.run(source, origin, Some(limit)).await
};
let state = match state {
Ok(state) => state,
Err(error) => return unavailable(format!("could not run: {error}")),
};
use incurs_codemode::ExecutionStatus;
match state.status {
ExecutionStatus::Completed => {}
ExecutionStatus::Running | ExecutionStatus::Paused => {
let _ = self.code.read().await.cancel(state.id.clone()).await;
return unavailable(format!("timed out after {} ms", decider.timeout_ms));
}
other => {
return unavailable(format!(
"the program ended {other:?}: {}",
state.error.unwrap_or_default()
));
}
}
let answer = state.result.unwrap_or(Value::Null);
let decision = answer
.get("decision")
.cloned()
.and_then(|decision| serde_json::from_value::<crate::intent::Decision>(decision).ok());
let Some(decision) = decision else {
return unavailable(format!(
"returned no decision of allow, refuse, or pending: {answer}"
));
};
crate::intent::DeciderAnswer {
decider: decider.name.clone(),
decision: Some(decision),
reason: answer
.get("reason")
.and_then(Value::as_str)
.unwrap_or_default()
.to_string(),
unavailable: None,
elapsed_ms: started.elapsed().as_millis() as u64,
}
}
pub(crate) fn serve_in_process(self: &Arc<Self>) -> Serving {
self.dispatch.serve(self)
}
pub(crate) fn stop(&self) {
self.shutdown.cancel();
}
pub(crate) async fn recover_owned_state(&self) -> Result<(), String> {
self.store.interrupt_orphaned_code_executions()?;
crate::run::interrupt_orphaned_runs(&self.store)?;
self.runs.recover().await?;
self.executions.recover()?;
self.polls.recover()?;
self.debugger.recover().await?;
self.recover_dap_adapters().await?;
self.recover_rr()?;
self.store.recover_hook_deliveries()?;
Ok(())
}
pub(crate) fn spawn_maintenance(daemon: &Arc<Daemon>) -> tokio::task::JoinHandle<()> {
let daemon = Arc::clone(daemon);
tokio::spawn(async move {
let mut cleanup = tokio::time::interval(Duration::from_secs(1));
cleanup.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut hooks = tokio::time::interval(Duration::from_millis(25));
hooks.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
tokio::select! {
_ = daemon.shutdown.cancelled() => break,
_ = hooks.tick() => {
if let Err(error) = daemon.dispatch_hook_deliveries().await {
tracing::warn!(error = %error, "could not dispatch hook deliveries");
}
}
_ = 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);
}
}
}
})
}
async fn recover_dap_adapters(&self) -> Result<(), String> {
let controller = default_controller();
for mut session in self.store.debugger_sessions()? {
if session.desired_state != DebuggerDesiredState::Open
|| !matches!(
session.adapter,
DebuggerAdapterKind::Dap | DebuggerAdapterKind::Lldb
)
{
continue;
}
let Some(execution_id) = session.execution_id.clone() else {
continue;
};
let result = self
.executions
.cancel_unclaimed(&execution_id, Duration::from_secs(5), &controller)
.await;
let (kind, details) = match result {
Ok(execution) => (
"debugger.dap.adapter_recovered",
serde_json::json!({
"reason":"daemon_restart",
"execution_status":execution.status
}),
),
Err(error) => (
"debugger.dap.adapter_recovery_failed",
serde_json::json!({"reason":"daemon_restart","error":error}),
),
};
session.observed_state.phase = crate::debugger::DebuggerPhase::Disconnected;
session.observed_state.connected = false;
session.observed_state.paused = false;
session.observed_state.frames.clear();
session.observed_state.hit_breakpoints.clear();
session.observed_state.error = Some(
"DAP adapter cannot reconnect after daemon restart; start a new debugger session"
.to_string(),
);
session.updated_at = now_ms();
self.store.put_debugger_session(&session)?;
self.store.append_debugger_event(DebuggerEvent {
sequence: 0,
id: uuid::Uuid::now_v7().to_string(),
session_id: session.id,
execution_id: Some(execution_id),
at: now_ms(),
kind: kind.to_string(),
details,
})?;
}
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) => {
crate::error_telemetry::record_rpc_at(
self.store
.path()
.parent()
.unwrap_or(std::path::Path::new(".")),
&request.method,
Some(&request.controller.invocation_id),
request.controller.execution_id.as_deref(),
&format!("DAEMON_REQUEST_FAILED: {message}"),
);
RpcResponse {
id: request.id,
result: None,
error: Some(RpcError {
code: "DAEMON_REQUEST_FAILED".to_string(),
message,
}),
}
}
};
let response_id = response.id.clone();
let encoded = serde_json::to_vec(&response).map_err(|error| error.to_string())?;
let encoded = if encoded.len() > MAX_FRAME_BYTES {
serde_json::to_vec(&RpcResponse {
id: response_id,
result: None,
error: Some(RpcError {
code: "DAEMON_RESPONSE_OVERSIZED".to_string(),
message: format!(
"{} produced {} bytes, over the {MAX_FRAME_BYTES} byte frame limit; \
ask for a bounded page instead",
request.method,
encoded.len()
),
}),
})
.map_err(|error| error.to_string())?
} else {
encoded
};
framed
.send(tokio_util::bytes::Bytes::from(encoded))
.await
.map_err(|error: std::io::Error| error.to_string())?;
}
Ok(())
}
async fn extension_status(&self) -> Result<ExtensionStatusView, String> {
let socket = runtime_dir().join(EXTENSION_SOCKET_NAME);
let bridge = self
.extension_bridge
.status(socket.display().to_string())
.await;
if !bridge.connected {
return Ok(ExtensionStatusView {
bridge,
extension: None,
});
}
let response = self
.extension_bridge
.request(serde_json::json!({"op":"status"}), Duration::from_secs(5))
.await?;
let extension = response
.get("status")
.cloned()
.ok_or_else(|| "extension status response omitted status".to_string())?;
let extension = serde_json::from_value::<ExtensionRuntimeStatus>(extension)
.map_err(|error| format!("invalid extension status response: {error}"))?;
Ok(ExtensionStatusView {
bridge,
extension: Some(extension),
})
}
async fn extension_mutation(
&self,
idempotency_key: String,
operation: &str,
request: Value,
timeout_ms: u64,
) -> Result<Value, String> {
let material = serde_json::json!({"id":"extension","request":request});
let bridge = self.extension_bridge.clone();
self.debugger
.mutation(idempotency_key, operation, material, move || async move {
bridge
.request(request, Duration::from_millis(timeout_ms.max(1)))
.await
})
.await
}
fn recover_rr(&self) -> Result<(), String> {
let traces = self.debugger.rr_recording_traces()?;
if traces.is_empty() {
return Ok(());
}
let executions = self.store.list_execution_records()?;
for trace in traces {
let execution_id = trace.execution_id.clone().or_else(|| {
let session_id = format!("rr:{}", trace.id);
executions
.iter()
.find(|execution| execution.session_id.as_deref() == Some(&session_id))
.map(|execution| execution.id.clone())
});
let Some(execution_id) = execution_id else {
self.debugger.rr_finish_record(
&trace.id,
false,
Some("Accepted rr trace has no durable execution".to_string()),
)?;
continue;
};
if trace.execution_id.as_deref() != Some(&execution_id) {
self.debugger
.rr_set_execution(&trace.id, execution_id.clone())?;
}
spawn_rr_finalizer(
self.debugger.clone(),
self.executions.clone(),
trace.id,
execution_id,
);
}
Ok(())
}
fn dispatch<'a>(
&'a self,
method: &'a str,
params: Value,
controller: &'a ProcessController,
) -> futures::future::BoxFuture<'a, Result<Value, String>> {
if method.starts_with("debugger.") {
Box::pin(self.dispatch_debugger(method, params, controller))
} else {
Box::pin(self.dispatch_control(method, params, controller))
}
}
async fn dispatch_control(
&self,
method: &str,
params: Value,
controller: &ProcessController,
) -> Result<Value, String> {
match method {
"daemon.status" | "daemon.ping" => json(self.status()?),
"gc.collect" => json(Box::pin(self.gc_command(params, controller)).await?),
"daemon.shutdown" => {
self.shutdown.cancel();
Ok(serde_json::json!({ "stopping": true }))
}
ImageImportOperation::METHOD => {
let params = parse::<ImageImportOperation>(params)?;
let source = resolve_controller_path(controller, ¶ms.source, "image source")?;
json(
Box::pin(self.isolation.image_import(
source,
¶ms.idempotency_key,
controller,
))
.await?,
)
}
"execution.start" => {
let mut params = parse::<ExecutionStartParams>(params)?;
validate_lifetime(params.keep_alive, params.lifetime_ms)?;
let (keep_alive, lifetime_ms) = (params.keep_alive, params.lifetime_ms);
normalize_execution_workspace(&mut params.spec, controller)?;
params.parent_id = params.parent_id.or_else(|| controller.execution_id.clone());
let cwd = params.spec.workspace.cwd.clone();
let parent_profile =
parent_profile_binding(&self.store, params.parent_id.as_deref(), controller)?;
bind_profile(
&self.store,
cwd.as_deref(),
params.profile.as_deref(),
parent_profile.as_ref(),
&mut params.spec,
)?;
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?;
self.register_unowned_lifetime(&execution, keep_alive, lifetime_ms)?;
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)?;
params.parent_id = params.parent_id.or_else(|| controller.execution_id.clone());
let cwd = params.spec.workspace.cwd.clone();
let parent_profile =
parent_profile_binding(&self.store, params.parent_id.as_deref(), controller)?;
bind_profile(
&self.store,
cwd.as_deref(),
params.profile.as_deref(),
parent_profile.as_ref(),
&mut params.spec,
)?;
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.isolation.status" => json(self.isolation.isolation_status().await?),
"execution.isolation.warmup" | "execution.isolation.drain" => {
let params = parse::<IsolationMutationParams>(params)?;
let action = method
.rsplit_once('.')
.map(|(_, action)| action)
.ok_or_else(|| format!("Invalid isolation operation {method}"))?;
json(
self.isolation
.isolation_mutation(
action,
params.arguments,
¶ms.idempotency_key,
controller,
)
.await?,
)
}
"execution.list" => {
let params = parse::<ExecutionListParams>(params)?;
json(self.executions.list_page(
params.limit,
params.cursor.as_deref(),
params.status,
params.error_code.as_deref(),
params.parent.as_deref(),
)?)
}
"execution.get" => {
let params = parse::<IdParams>(params)?;
self.touch_execution(¶ms.id);
json(self.executions.get(¶ms.id)?)
}
"execution.tree" => {
let params = parse::<IdParams>(params)?;
self.touch_execution(¶ms.id);
json(self.executions.tree(¶ms.id, controller)?)
}
"execution.telemetry.start" => {
let params = parse::<TelemetryStartParams>(params)?;
json(self.executions.start_telemetry(
¶ms.id,
params.interval_ms,
params.max_bytes,
¶ms.idempotency_key,
)?)
}
"execution.telemetry.get" => {
let params = parse::<TelemetryGetParams>(params)?;
if params.grep.is_some() || params.lines.is_some() {
json(self.executions.telemetry_slice(
¶ms.id,
params.grep.as_deref(),
params.context.unwrap_or(2),
params.max_matches.unwrap_or(20),
params.lines.as_deref(),
)?)
} else {
json(self.executions.telemetry_summary(¶ms.id)?)
}
}
"execution.telemetry.stop" => {
let params = parse::<TelemetryStopParams>(params)?;
json(
self.executions
.stop_telemetry(¶ms.id, ¶ms.idempotency_key)
.await?,
)
}
"execution.wait" => {
let params = parse::<WaitParams>(params)?;
self.touch_execution(¶ms.id);
let record = self.store.get_execution_record(¶ms.id)?;
if record.as_ref().is_some_and(|execution| {
matches!(
&execution.spec.program,
crate::model::ExecutionProgram::Javascript { .. }
)
}) {
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, None, None)?)
} else if record.is_some() {
let waited = self
.executions
.wait(¶ms.id, params.timeout_ms.map(Duration::from_millis))
.await;
self.touch_execution(¶ms.id);
json(waited?)
} 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, None, None)?)
}
}
"execution.cancel" => {
let params = parse::<StopParams>(params)?;
let idempotency_key = params
.idempotency_key
.ok_or_else(|| "execution.cancel requires idempotency_key".to_string())?;
let record = self.store.get_execution_record(¶ms.id)?;
if record.as_ref().is_some_and(|execution| {
matches!(
&execution.spec.program,
crate::model::ExecutionProgram::Javascript { .. }
)
}) {
let state = self.code.read().await.cancel(params.id).await?;
json(self.record_code_execution(&state, controller, None, None, None)?)
} else if record.is_some() {
self.polls.notify_cancel(¶ms.id)?;
json(
self.executions
.cancel(
¶ms.id,
Duration::from_millis(params.timeout_ms),
&idempotency_key,
controller,
)
.await?,
)
} else {
let state = self.code.read().await.cancel(params.id).await?;
json(self.record_code_execution(&state, controller, None, None, None)?)
}
}
"poll.start" | "poll.run" => {
let wait = method == "poll.run";
let mut params = parse::<ExecutionStartParams>(params)?;
normalize_execution_workspace(&mut params.spec, controller)?;
params.parent_id = params.parent_id.or_else(|| controller.execution_id.clone());
let cwd = params.spec.workspace.cwd.clone();
let parent_profile =
parent_profile_binding(&self.store, params.parent_id.as_deref(), controller)?;
bind_profile(
&self.store,
cwd.as_deref(),
params.profile.as_deref(),
parent_profile.as_ref(),
&mut params.spec,
)?;
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)?;
self.touch_execution(¶ms.id);
json(
self.executions
.signal(
¶ms.id,
¶ms.signal,
¶ms.idempotency_key,
controller,
)
.await?,
)
}
"execution.input" => {
let params = parse::<InputParams>(params)?;
self.touch_execution(¶ms.id);
json(
self.executions
.input(
¶ms.id,
params.data.as_bytes(),
¶ms.idempotency_key,
controller,
)
.await?,
)
}
"execution.logs" => {
let params = parse::<LogsParams>(params)?;
self.touch_execution(¶ms.id);
match log_slice_request(¶ms)? {
Some(request) => json(self.executions.log_slice(¶ms.id, &request)?),
None => json(self.executions.logs(¶ms.id, params.tail_bytes)?),
}
}
"execution.attach" => {
let params = parse::<LogsParams>(params)?;
self.touch_execution(¶ms.id);
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),
closing: false,
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.closing || 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::<TimeoutParams>(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 }))
}
"observe.capabilities" => json(self.store.observe_capabilities()),
"observe.projects" => json(self.store.observe_projects()?),
"observe.snapshot" | "observe.rows" | "observe.get" | "observe.tracks"
| "observe.watch" => {
let options = parse::<crate::observe::ObserveReadOptions>(params)?;
let query = options.query(controller.cwd.as_deref())?;
if method == "observe.tracks" {
return json(self.store.observe_tracks(&query)?);
}
if method == "observe.get" && query.id.is_none() {
return Err("OBSERVE_MISSING_ID: get requires an observation id".into());
}
if method != "observe.watch" {
return json(
self.store
.observe_snapshot(&query, options.next_page.as_deref())?,
);
}
if options.timeout_ms > 30_000 {
return Err("OBSERVE_INVALID_TIMEOUT: maximum watch wait is 30000 ms".into());
}
let after: crate::observe::ObserveCursor = serde_json::from_str(
options
.cursor
.as_deref()
.ok_or("OBSERVE_MISSING_CURSOR: take a snapshot first")?,
)
.map_err(|_| "OBSERVE_INVALID_CURSOR: expected the JSON snapshot cursor")?;
let deadline =
tokio::time::Instant::now() + Duration::from_millis(options.timeout_ms);
loop {
let page = self.store.observe_changes(&query, &after)?;
if !page.rows.is_empty() || tokio::time::Instant::now() >= deadline {
break json(page);
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
}
"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 selection = resolve_profile(
&self.store,
controller.cwd.as_deref(),
params.profile.as_deref(),
)?
.selection;
let mut origin = crate::code::RequestOrigin::from_controller(controller);
origin.profile_selection = selection.clone();
origin.purpose = Some(params.purpose.clone());
origin.idempotency_key = params.idempotency_key.clone();
let started = self.code.read().await.start(params.code, origin).await?;
self.record_code_execution(
&started,
controller,
Some(¶ms.purpose),
selection.as_ref(),
Some(¶ms.telemetry),
)?;
let _ = self
.executions
.ensure_telemetry(&started.id, ¶ms.telemetry);
let state = self
.code
.read()
.await
.wait(&started.id, Some(Duration::from_millis(params.timeout_ms)))
.await?;
self.record_code_execution(
&state,
controller,
Some(¶ms.purpose),
selection.as_ref(),
None,
)?;
Ok(execution_summary(&state))
}
"code.start" => {
let params = parse::<CodeParams>(params)?;
let selection = resolve_profile(
&self.store,
controller.cwd.as_deref(),
params.profile.as_deref(),
)?
.selection;
let mut origin = crate::code::RequestOrigin::from_controller(controller);
origin.profile_selection = selection.clone();
origin.purpose = Some(params.purpose.clone());
origin.idempotency_key = params.idempotency_key.clone();
let state = self.code.read().await.start(params.code, origin).await?;
self.record_code_execution(
&state,
controller,
Some(¶ms.purpose),
selection.as_ref(),
Some(¶ms.telemetry),
)?;
let _ = self
.executions
.ensure_telemetry(&state.id, ¶ms.telemetry);
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, None, None)?;
bounded_code_state(&state)
}
"code.wait" => {
let params = parse::<CodeWaitParams>(params)?;
let state = self
.code
.read()
.await
.wait(¶ms.id, Some(Duration::from_millis(params.timeout_ms)))
.await?;
self.record_code_execution(&state, controller, None, None, None)?;
bounded_code_state(&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, None, None)?;
bounded_code_state(&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
}
"profile.create"
| "profile.remove"
| "profile.root.add"
| "profile.root.remove"
| "profile.default" => {
let params = parse::<ProfileMutationParams>(params)?;
let key = params
.idempotency_key
.as_deref()
.ok_or_else(|| format!("{method} requires idempotency_key"))?;
let fingerprint = recipe_request_fingerprint(method, ¶ms)?;
if let Some(output) = recipe_replay(&self.store, Some(key), method, &fingerprint)? {
return Ok(output);
}
let output = match method {
"profile.create" => {
let name = required_profile_name(params.name.as_deref())?;
if self.store.get_profile(name)?.is_some() {
return Err(format!(
"PROFILE_EXISTS: profile \"{name}\" already exists"
));
}
self.store.put_profile(&Profile::empty(name))?;
serde_json::to_value(profile_view_by_name(&self.store, name)?)
}
"profile.remove" => {
let name = required_profile_name(params.name.as_deref())?;
let removed = self.store.delete_profile(name)?;
Ok(serde_json::json!({ "name": name, "removed": removed }))
}
"profile.root.add" => {
let name = required_profile_name(params.name.as_deref())?;
profile_view_by_name(&self.store, name)?;
let path = params
.path
.as_deref()
.ok_or_else(|| "Profile root path is required".to_string())?;
let root = canonical_path(path)?;
self.store.put_profile_root(name, &root)?;
serde_json::to_value(profile_view_by_name(&self.store, name)?)
}
"profile.root.remove" => {
let name = required_profile_name(params.name.as_deref())?;
profile_view_by_name(&self.store, name)?;
let path = params
.path
.as_deref()
.ok_or_else(|| "Profile root path is required".to_string())?;
let roots = self.store.roots_for_profile(name)?;
let root = if roots.iter().any(|root| root == path) {
path.to_string()
} else {
canonical_path(path)?
};
self.store.delete_profile_root(name, &root)?;
serde_json::to_value(profile_view_by_name(&self.store, name)?)
}
"profile.default" => {
if params.clear && params.name.is_some() {
return Err(
"--clear and a profile name cannot be used together".to_string()
);
}
if params.clear {
self.store.set_default_profile(None)?;
Ok(serde_json::json!({ "name": null }))
} else {
let name = required_profile_name(params.name.as_deref())?;
profile_view_by_name(&self.store, name)?;
self.store.set_default_profile(Some(name))?;
Ok(serde_json::json!({ "name": name }))
}
}
_ => unreachable!(),
}
.map_err(|error: serde_json::Error| error.to_string())?;
recipe_record_replay(&self.store, Some(key), method, &fingerprint, &output)?;
Ok(output)
}
"profile.list" => json(profile_views(&self.store)?),
"profile.show" => {
let params = parse::<ProfileLookupParams>(params)?;
let name = required_profile_name(params.name.as_deref())?;
json(profile_view_by_name(&self.store, name)?)
}
"profile.resolve" | "profile.doctor" => {
let params = parse::<ProfileLookupParams>(params)?;
let cwd = params.cwd.as_deref().or(controller.cwd.as_deref());
json(resolve_profile(
&self.store,
cwd,
params.profile.as_deref(),
)?)
}
"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 profile_name = environment_profile_name(
&self.store,
selected_cwd,
params.global,
params.profile.as_deref(),
true,
)?
.ok_or_else(|| {
"PROFILE_NOT_SELECTED: create, map, or set a default profile first".to_string()
})?;
let fingerprint = recipe_request_fingerprint(method, ¶ms)?;
if let Some(output) = recipe_replay(&self.store, Some(key), method, &fingerprint)? {
return Ok(output);
}
let mut profile = self.store.get_profile(&profile_name)?.ok_or_else(|| {
format!("PROFILE_NOT_FOUND: profile \"{profile_name}\" does not exist")
})?;
if method == "env.clear" {
profile.literals.clear();
profile.secrets.clear();
} else {
let name = params
.name
.as_deref()
.ok_or_else(|| "Environment name is required".to_string())?;
validate_environment_name(name)?;
if matches!(method, "env.set" | "env.secret") {
reject_provider_ambient_profile_key(&self.store, name)?;
}
match method {
"env.set" => {
let value = params.value.ok_or_else(|| {
"Environment literal value is required".to_string()
})?;
profile.secrets.remove(name);
profile.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());
}
profile.literals.remove(name);
profile.secrets.insert(name.to_string(), secret);
}
"env.unset" => {
profile.literals.remove(name);
profile.secrets.remove(name);
}
_ => unreachable!(),
}
}
profile.refresh_generation();
self.store.put_profile(&profile)?;
let output =
serde_json::to_value(Some(profile_view_by_name(&self.store, &profile_name)?))
.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());
let name = environment_profile_name(
&self.store,
selected_cwd,
params.global,
params.profile.as_deref(),
false,
)?;
json(
name.as_deref()
.map(|name| profile_view_by_name(&self.store, name))
.transpose()?,
)
}
"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,
origin_recording_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()),
origin_recording_id: None,
};
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)
}
"hook.put" => {
let params = parse::<HookPutParams>(params)?;
validate_hook_definition(¶ms)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let now = now_ms();
let created_at = self
.store
.get_hook(scope_kind, scope_key.as_deref(), ¶ms.name)?
.map_or(now, |hook| hook.created_at);
let mut hook = Hook {
name: params.name,
command: params.command,
on_start: params.on_start,
on_success: params.on_success,
on_failure: params.on_failure,
enabled: params.enabled,
max_attempts: params.max_attempts,
timeout_ms: params.timeout_ms,
scope_kind,
scope_key,
created_at,
updated_at: now,
generation: String::new(),
};
hook.generation = hook_generation(&hook)?;
self.store.put_hook(&hook)?;
json(hook)
}
"hook.get" => {
let params = parse::<HookLookupParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let hook =
visible_hook(&self.store, scope_kind, scope_key.as_deref(), ¶ms.name)?
.ok_or_else(|| {
format!("HOOK_NOT_FOUND: Hook \"{}\" not found", params.name)
})?;
json(hook)
}
"decider.put" => {
let params = parse::<DeciderPutParams>(params)?;
if params.name.trim().is_empty() {
return Err("DECIDER_INVALID: a decider needs a name".to_string());
}
if params.program.trim().is_empty() {
return Err("DECIDER_INVALID: a decider needs a program".to_string());
}
if !(1..=60_000).contains(¶ms.timeout_ms) {
return Err(
"DECIDER_INVALID: timeout_ms must be between 1 and 60000".to_string()
);
}
let now = now_ms();
let created_at = self
.store
.list_deciders()?
.into_iter()
.find(|decider| decider.name == params.name)
.map_or(now, |decider| decider.created_at);
let decider = crate::intent::Decider {
name: params.name,
program: params.program,
verbs: params.verbs,
enabled: params.enabled,
timeout_ms: params.timeout_ms,
on_unavailable: params.on_unavailable,
created_at,
updated_at: now,
};
self.store.put_decider(&decider)?;
self.gate.refresh()?;
json(decider)
}
"decider.list" => json(self.store.list_deciders()?),
"decider.remove" => {
let params = parse::<DeciderNameParams>(params)?;
let removed = self.store.delete_decider(¶ms.name)?;
self.gate.refresh()?;
Ok(serde_json::json!({"id": params.name, "removed": removed}))
}
"intent.list" => {
let params = parse::<IntentListParams>(params)?;
let limit = params.limit.unwrap_or(50).clamp(1, 500);
json(self.store.list_intent_records(limit)?)
}
"hook.list" => {
let params = parse::<HookScopeParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
json(visible_hooks(
&self.store,
scope_kind,
scope_key.as_deref(),
)?)
}
"hook.remove" => {
let params = parse::<HookLookupParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
let removed =
self.store
.delete_hook(scope_kind, scope_key.as_deref(), ¶ms.name)?;
Ok(serde_json::json!({"id": params.name, "removed": removed}))
}
"hook.delivery" => {
let params = parse::<IdParams>(params)?;
json(
self.store
.get_hook_delivery(¶ms.id)?
.ok_or_else(|| format!("HOOK_DELIVERY_NOT_FOUND: {}", params.id))?,
)
}
"hook.deliveries" => {
let params = parse::<HookDeliveryListParams>(params)?;
let status = params
.status
.map(|status| {
serde_json::from_value::<HookDeliveryStatus>(Value::String(status))
.map_err(|_| {
"HOOK_STATUS_INVALID: Expected pending, running, succeeded, or failed"
.to_string()
})
})
.transpose()?;
json(
self.store
.list_hook_deliveries(params.hook.as_deref(), status)?,
)
}
"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,
origin_recording_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,
origin_recording_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 profile_selection =
resolve_profile(&self.store, recipe_cwd, params.profile.as_deref())?.selection;
let available = profile_selection
.clone()
.map(|selection| profile_view_by_name(&self.store, &selection.name))
.transpose()?;
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.as_ref().is_some_and(|available| {
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,
crate::code::RequestOrigin {
cwd: recipe_cwd.map(ToString::to_string),
verbosity: Some(crate::model::Verbosity::Trace.as_str().to_string()),
profile_selection: profile_selection.clone(),
hook_depth: controller.hook_depth,
decider_depth: controller.decider_depth,
..Default::default()
},
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)
}
RecipeRecordingStartOperation::METHOD => {
let params = parse::<RecipeRecordingStartOperation>(params)?;
validate_recipe_name(¶ms.name)?;
let key = params.idempotency_key.as_str();
let fingerprint = recipe_request_fingerprint("recording.start", ¶ms)?;
if let Some(output) =
recipe_replay(&self.store, Some(key), "recording.start", &fingerprint)?
{
return Ok(output);
}
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
if let Some(active) = self
.store
.active_recording_in_recipe_scope(scope_kind, scope_key.as_deref())?
{
return Err(format!(
"RECORDING_ACTIVE: Recording \"{}\" is already capturing this scope",
active.name
));
}
let now = now_ms();
let existing = self.store.get_recording_by_name(
scope_kind,
scope_key.as_deref(),
¶ms.name,
)?;
let mut recording = match existing {
Some(existing) if params.replace => {
self.store.delete_recording(&existing.id)?;
None
}
Some(existing) => Some(existing),
None => None,
}
.unwrap_or_else(|| Recording {
id: uuid::Uuid::now_v7().to_string(),
name: params.name.clone(),
status: RecordingStatus::Active,
scope_kind,
scope_key: scope_key.clone(),
takes: Vec::new(),
literal_paths: Vec::new(),
skipped: Vec::new(),
evidence: Vec::new(),
recipe_generation: None,
suggestion_id: None,
created_at: now,
updated_at: now,
});
let index = recording.takes.len() as u32 + 1;
recording.takes.push(RecordingTake {
index,
started_at: now,
stopped_at: None,
params: Vec::new(),
});
recording.status = RecordingStatus::Active;
recording.evidence.clear();
recording.recipe_generation = None;
recording.suggestion_id = None;
recording.updated_at = now;
self.store.put_recording(&recording)?;
let output = json(&recording)?;
recipe_record_replay(
&self.store,
Some(key),
"recording.start",
&fingerprint,
&output,
)?;
Ok(output)
}
"recording.param" => {
let params = parse::<RecordingParamParams>(params)?;
let mut recording = self.require_active_recording(controller, ¶ms.scope)?;
let (name, value) = params
.assignment
.split_once('=')
.ok_or_else(|| "Parameters must use NAME=VALUE".to_string())?;
validate_input_name(name)?;
let value = if params.json {
serde_json::from_str::<Value>(value)
.map_err(|error| format!("Parameter value is not valid JSON: {error}"))?
} else {
Value::String(value.to_string())
};
let take = recording
.takes
.last_mut()
.ok_or_else(|| "Recording has no open take".to_string())?;
take.params.retain(|param| param.name != name);
take.params.push(RecordingParam {
name: name.to_string(),
value,
});
recording.updated_at = now_ms();
self.store.put_recording(&recording)?;
json(recording)
}
"recording.literal" => {
let params = parse::<RecordingLiteralParams>(params)?;
let mut recording = self.require_active_recording(controller, ¶ms.scope)?;
if !params.path.starts_with('$') {
return Err("Literal paths must start with \"$\"".to_string());
}
if !recording.literal_paths.contains(¶ms.path) {
recording.literal_paths.push(params.path);
}
recording.updated_at = now_ms();
self.store.put_recording(&recording)?;
json(recording)
}
"recording.status" => {
let params = parse::<RecordingScopeParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
match self
.store
.active_recording_in_recipe_scope(scope_kind, scope_key.as_deref())?
{
Some(recording) => json(self.recording_detail(recording)?),
None => Ok(Value::Null),
}
}
"recording.list" => {
let params = parse::<RecordingScopeParams>(params)?;
let (scope_kind, scope_key) =
selected_recipe_scope(controller, params.global, params.cwd.as_deref())?;
json(
self.store
.list_recordings(scope_kind, scope_key.as_deref())?,
)
}
RecipeRecordingGetOperation::METHOD => {
let params = parse::<RecipeRecordingGetOperation>(params)?;
let recording = self
.store
.get_recording(¶ms.id)?
.ok_or_else(|| format!("Recording \"{}\" not found", params.id))?;
json(self.recording_detail(recording)?)
}
"recording.discard" => {
let params = parse::<RecordingMutationParams>(params)?;
let key = params
.idempotency_key
.as_deref()
.ok_or_else(|| "recording discard requires idempotency_key".to_string())?;
let fingerprint = recipe_request_fingerprint("recording.discard", ¶ms)?;
if let Some(output) =
recipe_replay(&self.store, Some(key), "recording.discard", &fingerprint)?
{
return Ok(output);
}
let mut recording = self.require_active_recording(controller, ¶ms.scope)?;
recording.status = RecordingStatus::Discarded;
recording.updated_at = now_ms();
self.store.put_recording(&recording)?;
let output = json(&recording)?;
recipe_record_replay(
&self.store,
Some(key),
"recording.discard",
&fingerprint,
&output,
)?;
Ok(output)
}
RecipeRecordingStopOperation::METHOD => {
let params = parse::<RecipeRecordingStopOperation>(params)?;
let key = params.idempotency_key.as_str();
if params.ttl_ms == Some(0) {
return Err("Recording ttl_ms must be greater than zero".to_string());
}
let fingerprint = recipe_request_fingerprint("recording.stop", ¶ms)?;
if let Some(output) =
recipe_replay(&self.store, Some(key), "recording.stop", &fingerprint)?
{
return Ok(output);
}
let scope = RecordingScopeParams {
global: params.global,
cwd: params.cwd.clone(),
};
let mut recording = self.require_active_recording(controller, &scope)?;
if let Some(name) = ¶ms.name
&& name != &recording.name
{
return Err(format!(
"RECORDING_NAME_MISMATCH: Recording \"{}\" is active, not \"{name}\"",
recording.name
));
}
for id in ¶ms.skip {
if !recording.skipped.contains(id) {
recording.skipped.push(id.clone());
}
}
let now = now_ms();
if let Some(take) = recording.takes.last_mut() {
take.stopped_at = Some(now);
}
let takes = self.recording_takes(&recording)?;
let emitted = crate::recording::emit(
&takes,
&recording_params(&recording),
&recording.literal_paths,
&recording.name,
)?;
recording.evidence = self.recording_evidence(&recording)?;
recording.status = RecordingStatus::Stopped;
recording.updated_at = now;
let mut recipe = None;
let mut suggestion = None;
if params.suggest {
if recording.evidence.len() < 2 {
return Err(
"RECORDING_EVIDENCE: A suggestion needs at least two takes".to_string()
);
}
let mut candidate = Recipe {
name: recording.name.clone(),
description: emitted.description.clone(),
code: emitted.code.clone(),
input_schema: Some(emitted.input_schema.clone()),
output_schema: None,
dependencies: Vec::new(),
required_env: Vec::new(),
annotations: RecipeAnnotations::default(),
scope_kind: recording.scope_kind,
scope_key: recording.scope_key.clone(),
generation: String::new(),
expires_at: None,
last_used_at: None,
created_at: now,
updated_at: now,
origin_suggestion_id: None,
origin_recording_id: Some(recording.id.clone()),
};
candidate.generation = recipe_generation(&candidate)?;
let stored = RecipeSuggestion {
id: uuid::Uuid::now_v7().to_string(),
candidate: portable_recipe(&candidate),
positive_evidence: recording.evidence.clone(),
counterexamples: Vec::new(),
rationale: format!(
"Captured by recording \"{}\" across {} takes.",
recording.name,
recording.takes.len()
),
scope_kind: recording.scope_kind,
scope_key: recording.scope_key.clone(),
status: RecipeSuggestionStatus::Pending,
adopted_generation: None,
created_at: now,
adopted_at: None,
};
recording.suggestion_id = Some(stored.id.clone());
suggestion = Some(stored);
} else {
let existing = self.store.get_recipe_definition(
recording.scope_kind,
recording.scope_key.as_deref(),
&recording.name,
)?;
if let Some(existing) = &existing
&& existing.origin_recording_id.as_deref() != Some(recording.id.as_str())
&& !params.replace
{
return Err(format!(
"RECORDING_STOP_CONFLICT: Recipe \"{}\" already exists from another origin",
recording.name
));
}
let mut written = Recipe {
name: recording.name.clone(),
description: emitted.description.clone(),
code: emitted.code.clone(),
input_schema: Some(emitted.input_schema.clone()),
output_schema: None,
dependencies: Vec::new(),
required_env: Vec::new(),
annotations: RecipeAnnotations::default(),
scope_kind: recording.scope_kind,
scope_key: recording.scope_key.clone(),
generation: String::new(),
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: None,
origin_recording_id: Some(recording.id.clone()),
};
written.generation = recipe_generation(&written)?;
validate_recipe_schema(
written.input_schema.as_ref(),
"RECIPE_INPUT_SCHEMA_INVALID",
)?;
recording.recipe_generation = Some(written.generation.clone());
recipe = Some(written);
}
let output = json(RecordingStopOutput {
recording: recording.clone(),
recipe: recipe.clone(),
suggestion: suggestion.clone(),
})?;
self.store.publish_recording_stop(
&recording,
recipe.as_ref(),
suggestion.as_ref(),
&format!("recipe:{key}"),
"recipe_replay",
&RecipeReplay {
operation: "recording.stop".to_string(),
fingerprint,
output: output.clone(),
},
)?;
Ok(output)
}
"provider.put" | "connector.put" => {
let params = parse::<ProviderPutParams>(params)?;
let mut material = params.config.clone();
material.generation.clear();
material.created_at = 0;
material.updated_at = 0;
let operation = "provider.put";
let fingerprint = provider_request_fingerprint(operation, &material)?;
if let Some(result) = provider_mutation_replay(
&self.store,
¶ms.idempotency_key,
operation,
&fingerprint,
)? {
return result;
}
let result = async {
self.ensure_code_idle().await?;
let config = params.config;
if !valid_provider_name(&config.name) {
return Err(format!(
"Provider \"{}\" is not a valid JavaScript namespace",
config.name
));
}
validate_provider_profile_config(&self.store, &config)?;
self.store.put_provider(
&config.name,
&serde_json::to_value(&config).map_err(|error| error.to_string())?,
)?;
self.reload_code().await?;
json(config)
}
.await;
provider_mutation_record(
&self.store,
¶ms.idempotency_key,
operation,
&fingerprint,
&result,
)?;
result
}
"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::<ProviderLookupParams>(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())?;
validate_provider_profile_config(&self.store, &config)?;
let resolution = resolve_profile(
&self.store,
params.cwd.as_deref().or(controller.cwd.as_deref()),
params.profile.as_deref(),
)?;
let profile = resolution
.selection
.as_ref()
.map(|selection| {
self.store
.get_profile_generation(&selection.name, &selection.generation)
})
.transpose()?
.flatten();
let connector = external_connector_for_profile(
config.clone(),
self.store.clone(),
profile.as_ref(),
)?;
let description = connector.describe().await?;
let capabilities = capability_descriptors(&config, &description);
Ok(serde_json::json!({
"provider": config.name,
"profile": resolution.selection,
"generation": config.generation,
"instructions": description.instructions,
"capabilities": capabilities
}))
}
"provider.refresh" => {
let params = parse::<ProviderRefreshParams>(params)?;
let operation = "provider.refresh";
let fingerprint = provider_request_fingerprint(
operation,
&serde_json::json!({
"id": params.id,
"cwd": params.cwd,
"profile": params.profile,
}),
)?;
if let Some(result) = provider_mutation_replay(
&self.store,
¶ms.idempotency_key,
operation,
&fingerprint,
)? {
return result;
}
let result = async {
self.ensure_code_idle().await?;
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())?;
validate_provider_profile_config(&self.store, &config)?;
let resolution = resolve_profile(
&self.store,
params.cwd.as_deref().or(controller.cwd.as_deref()),
params.profile.as_deref(),
)?;
let profile = resolution
.selection
.as_ref()
.map(|selection| {
self.store
.get_profile_generation(&selection.name, &selection.generation)
})
.transpose()?
.flatten();
let connector = external_connector_for_profile(
config.clone(),
self.store.clone(),
profile.as_ref(),
)?;
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,
"profile": resolution.selection,
"generation": config.generation,
"capabilities": capabilities
}))
}
.await;
provider_mutation_record(
&self.store,
¶ms.idempotency_key,
operation,
&fingerprint,
&result,
)?;
result
}
"provider.remove" | "connector.remove" => {
let params = parse::<ProviderMutationParams>(params)?;
let operation = "provider.remove";
let fingerprint = provider_request_fingerprint(operation, ¶ms.id)?;
if let Some(result) = provider_mutation_replay(
&self.store,
¶ms.idempotency_key,
operation,
&fingerprint,
)? {
return result;
}
let result = async {
self.ensure_code_idle().await?;
let removed = self.store.delete_provider(¶ms.id)?;
self.reload_code().await?;
Ok(serde_json::json!({ "id": params.id, "removed": removed }))
}
.await;
provider_mutation_record(
&self.store,
¶ms.idempotency_key,
operation,
&fingerprint,
&result,
)?;
result
}
_ => Err(format!("Unknown daemon method \"{method}\"")),
}
}
async fn dispatch_debugger(
&self,
method: &str,
params: Value,
controller: &ProcessController,
) -> Result<Value, String> {
match method {
DebuggerLegacyImportOperation::METHOD => {
let params = parse::<DebuggerLegacyImportOperation>(params)?;
let source = resolve_controller_path(controller, ¶ms.source, "legacy source")?;
let index = params
.index
.as_deref()
.map(|path| resolve_controller_path(controller, path, "legacy index"))
.transpose()?;
let artifacts = params
.artifacts
.iter()
.map(|path| resolve_controller_path(controller, path, "legacy artifact"))
.collect::<Result<Vec<_>, _>>()?;
let material = serde_json::json!({
"id":"legacy-debugger-index",
"source":source.display().to_string(),
"index":index.as_ref().map(|path| path.display().to_string()),
"artifacts":artifacts.iter().map(|path| path.display().to_string()).collect::<Vec<_>>(),
"replace":params.replace
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
validate_legacy_debugger_artifacts(&artifacts)?;
let mut migration = migrate_legacy_debugger(
&source,
index.as_deref(),
params.replace,
)?;
let imported =
debugger.import_legacy_debugger_artifacts(&artifacts)?;
attach_legacy_artifact_summary(&mut migration, imported);
Ok(migration)
},
)
.await?,
)
}
DebuggerLegacyQueryOperation::METHOD => {
let params = parse::<DebuggerLegacyQueryOperation>(params)?;
let index = params
.index
.as_deref()
.map(|path| resolve_controller_path(controller, path, "legacy index"))
.transpose()?;
json(query_legacy_debugger(
index.as_deref(),
¶ms.sql,
params.limit,
)?)
}
DebuggerLegacyStatusOperation::METHOD => {
let params = parse::<DebuggerLegacyStatusOperation>(params)?;
let index = params
.index
.as_deref()
.map(|path| resolve_controller_path(controller, path, "legacy index"))
.transpose()?;
json(legacy_debugger_status(index.as_deref())?)
}
DebuggerExtensionInstallHostOperation::METHOD => {
let params = parse::<DebuggerExtensionInstallHostOperation>(params)?;
let host_path = params
.host_path
.as_deref()
.map(|path| resolve_controller_path(controller, path, "native host executable"))
.transpose()?;
let home = params
.home
.as_deref()
.map(|path| resolve_controller_path(controller, path, "user home"))
.transpose()?;
let user_data_dir = params
.user_data_dir
.as_deref()
.map(|path| {
resolve_controller_path(controller, path, "browser user data directory")
})
.transpose()?;
let material = serde_json::json!({
"id":format!("extension-host:{}", params.browser),
"browser":params.browser,
"extension_id":params.extension_id,
"host_name":params.host_name,
"host_path":host_path,
"home":home,
"user_data_dir":user_data_dir,
"dry_run":params.dry_run
});
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
install_extension_host(
¶ms.browser,
¶ms.extension_id,
¶ms.host_name,
host_path.as_deref().and_then(std::path::Path::to_str),
home.as_deref().and_then(std::path::Path::to_str),
user_data_dir.as_deref().and_then(std::path::Path::to_str),
params.dry_run,
)
},
)
.await?,
)
}
DebuggerExtensionDoctorOperation::METHOD => {
let params = parse::<DebuggerExtensionDoctorOperation>(params)?;
let host_path = params
.host_path
.as_deref()
.map(|path| resolve_controller_path(controller, path, "native host executable"))
.transpose()?;
let home = params
.home
.as_deref()
.map(|path| resolve_controller_path(controller, path, "user home"))
.transpose()?;
let user_data_dir = params
.user_data_dir
.as_deref()
.map(|path| {
resolve_controller_path(controller, path, "browser user data directory")
})
.transpose()?;
json(extension_doctor(
¶ms.browser,
¶ms.host_name,
host_path.as_deref().and_then(std::path::Path::to_str),
home.as_deref().and_then(std::path::Path::to_str),
user_data_dir.as_deref().and_then(std::path::Path::to_str),
)?)
}
DebuggerExtensionBridgeOperation::METHOD | DebuggerExtensionStatusOperation::METHOD => {
json(self.extension_status().await?)
}
DebuggerExtensionTabsOperation::METHOD => {
let _ = parse::<DebuggerExtensionTabsOperation>(params)?;
let response = self
.extension_bridge
.request(serde_json::json!({"op":"tabs"}), Duration::from_secs(15))
.await?;
let tabs = response
.get("tabs")
.cloned()
.ok_or_else(|| "extension tabs response omitted tabs".to_string())?;
json(
serde_json::from_value::<Vec<ExtensionTab>>(tabs)
.map_err(|error| format!("invalid extension tabs response: {error}"))?,
)
}
DebuggerExtensionAttachOperation::METHOD => {
let params = parse::<DebuggerExtensionAttachOperation>(params)?;
let request = serde_json::json!({"op":"attach","tabId":params.tab_id});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionDetachOperation::METHOD => {
let params = parse::<DebuggerExtensionDetachOperation>(params)?;
let request = serde_json::json!({"op":"detach","tabId":params.tab_id});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionEvaluateOperation::METHOD => {
let params = parse::<DebuggerExtensionEvaluateOperation>(params)?;
let request = serde_json::json!({
"op":"eval",
"tabId":params.tab_id,
"expression":params.expression,
"world":params.world
});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionCdpOperation::METHOD => {
let params = parse::<DebuggerExtensionCdpOperation>(params)?;
let request = serde_json::json!({
"op":"cdp",
"tabId":params.tab_id,
"method":params.method,
"params":params.params
});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionSnapshotOperation::METHOD => {
let params = parse::<DebuggerExtensionSnapshotOperation>(params)?;
let request = serde_json::json!({
"op":"snapshot",
"tabId":params.tab_id,
"options":{
"dom":params.dom,
"state":params.state,
"storage":params.storage,
"react":params.react
}
});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionObserveOperation::METHOD => {
let params = parse::<DebuggerExtensionObserveOperation>(params)?;
let request = serde_json::json!({
"op":"observe",
"tabId":params.tab_id,
"kinds":params.kinds
});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionUnobserveOperation::METHOD => {
let params = parse::<DebuggerExtensionUnobserveOperation>(params)?;
let request = serde_json::json!({"op":"unobserve","tabId":params.tab_id});
json(
self.extension_mutation(
params.idempotency_key,
method,
request,
params.timeout_ms,
)
.await?,
)
}
DebuggerExtensionEventsOperation::METHOD => {
let params = parse::<DebuggerExtensionEventsOperation>(params)?;
json(
self.extension_bridge
.events(params.after, params.limit)
.await,
)
}
AppleDevicesOperation::METHOD => {
let params = parse::<AppleDevicesOperation>(params)?;
json(self.apple_device.devices(¶ms.platform).await?)
}
AppleAppsOperation::METHOD => {
let params = parse::<AppleAppsOperation>(params)?;
if params.device_id.trim().is_empty() {
return Err("Apple app listing requires device_id".to_string());
}
json(self.apple_device.apps(¶ms.device_id).await?)
}
AppleResolveOperation::METHOD => {
let params = parse::<AppleResolveOperation>(params)?;
if params.bundle_id.trim().is_empty() {
return Err("Apple attach resolution requires bundle_id".to_string());
}
let request = AppleAttachRequest {
bundle_id: params.bundle_id.clone(),
platform: params.platform.clone(),
device: params.device.clone(),
pid: params.pid,
launch: params.launch,
attach_strategy: params.attach_strategy.clone(),
attach_timeout_ms: params.attach_timeout_ms,
};
let material = serde_json::json!({
"id":params.id,
"bundle_id":params.bundle_id,
"platform":params.platform,
"device":params.device,
"pid":params.pid,
"launch":params.launch,
"attach_strategy":params.attach_strategy,
"attach_timeout_ms":params.attach_timeout_ms
});
let provider = self.apple_device.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { provider.resolve(request).await },
)
.await?,
)
}
AppleAttachOperation::METHOD => {
let params = parse::<AppleAttachOperation>(params)?;
if params.bundle_id.trim().is_empty() {
return Err("Apple attach requires bundle_id".to_string());
}
if params.adapter_argv.is_empty() {
return Err("Apple attach requires adapter argv".to_string());
}
let request = AppleAttachRequest {
bundle_id: params.bundle_id.clone(),
platform: params.platform.clone(),
device: params.device.clone(),
pid: params.pid,
launch: params.launch,
attach_strategy: params.attach_strategy.clone(),
attach_timeout_ms: params.timeout_ms,
};
let material = serde_json::json!({
"id":params.id,
"bundle_id":params.bundle_id,
"platform":params.platform,
"device":params.device,
"pid":params.pid,
"launch":params.launch,
"attach_strategy":params.attach_strategy,
"adapter_argv":params.adapter_argv,
"cwd":params.cwd,
"env":params.env,
"timeout_ms":params.timeout_ms
});
let provider = self.apple_device.clone();
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let resolution = provider.resolve(request).await?;
let strategies = apple_attach_strategy_order(
¶ms.attach_strategy,
&resolution,
)?;
let started_stopped = resolution
.metadata
.get("started_stopped")
.and_then(Value::as_bool)
.unwrap_or(false);
let stable_target = apple_stable_target(&resolution);
let mut attempted_strategies = Vec::new();
let mut last_error = None;
for strategy in strategies {
attempted_strategies.push(strategy.as_str().to_string());
let proxy_port = if strategy == AppleAttachStrategy::GdbRemote {
Some(
provider.debug_proxy(&resolution.device_id).await?.port,
)
} else {
None
};
let arguments = apple_dap_attach_arguments(
&resolution,
strategy,
params.timeout_ms,
proxy_port,
)?;
let attempt_key =
format!("{mutation_key}/{}", strategy.as_str());
match execute_dap_attach(
debugger.clone(),
executions.clone(),
store.clone(),
controller.clone(),
DapAttachExecutionInput {
id: params.id.clone(),
adapter_argv: params.adapter_argv.clone(),
stable_target: stable_target.clone(),
attach_arguments: arguments,
started_stopped,
cwd: params.cwd.clone(),
env: params.env.clone(),
timeout_ms: params.timeout_ms,
idempotency_key: attempt_key,
},
)
.await
{
Ok(debugger) => {
return Ok(AppleAttachResult {
resolution,
selected_strategy: strategy.as_str().to_string(),
attempted_strategies,
debugger,
});
}
Err(error) => last_error = Some(error),
}
}
Err(last_error.unwrap_or_else(|| {
"Apple attach had no eligible strategies".to_string()
}))
},
)
.await?,
)
}
DapLaunchOperation::METHOD => {
let params = parse::<DapLaunchOperation>(params)?;
if params.adapter_argv.is_empty() {
return Err("DAP launch requires adapter argv".to_string());
}
if params.program.trim().is_empty() {
return Err("DAP launch requires a program".to_string());
}
let material = serde_json::json!({
"id":params.id,"adapter_argv":params.adapter_argv,
"program":params.program,"args":params.args,"cwd":params.cwd,
"env":params.env,"timeout_ms":params.timeout_ms
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let mut spec = dap_execution_spec(DapExecutionSpecInput {
id: ¶ms.id,
idempotency_key: format!("{mutation_key}/adapter"),
adapter_argv: params.adapter_argv,
cwd: params.cwd.clone(),
env: params.env,
});
normalize_execution_workspace(&mut spec, &controller)?;
let cwd = spec.workspace.cwd.clone();
bind_profile(
&store,
cwd.as_deref(),
None,
parent_profile_binding(
&store,
controller.execution_id.as_deref(),
&controller,
)?
.as_ref(),
&mut spec,
)?;
let execution = executions
.start(spec, controller.clone(), None, Some(params.id.clone()))
.await?;
let timeout =
Duration::from_millis(params.timeout_ms.clamp(1, 120_000));
let opened = async {
debugger
.dap_open(
params.id.clone(),
params.program.clone(),
execution.id.clone(),
executions.clone(),
controller.clone(),
)
.await?;
let mut launch_arguments = serde_json::json!({
"program":params.program,
"cwd":cwd,
"args":params.args,
"stopOnEntry":true
});
crate::debugger::dap::merge_init_commands(
&mut launch_arguments,
crate::debugger::dap::rust_init_commands(),
);
debugger
.dap_request(
¶ms.id,
"launch",
launch_arguments,
timeout,
)
.await?;
debugger
.dap_request(
¶ms.id,
"configurationDone",
serde_json::json!({}),
timeout,
)
.await?;
debugger.dap_wait_for_pause(¶ms.id, 0, timeout).await?;
debugger.status(¶ms.id).await
}
.await;
match opened {
Ok(session) => Ok(DebuggerRunResult { execution, session }),
Err(error) => {
let _ = debugger
.dap_mark_error(¶ms.id, error.clone())
.await;
let _ = executions
.cancel_unclaimed(
&execution.id,
Duration::from_secs(5),
&controller,
)
.await;
Err(error)
}
}
},
)
.await?,
)
}
DapAttachOperation::METHOD => {
let params = parse::<DapAttachOperation>(params)?;
if params.adapter_argv.is_empty() {
return Err("DAP attach requires adapter argv".to_string());
}
if params.pid == 0 {
return Err("DAP attach requires a positive PID".to_string());
}
let material = serde_json::json!({
"id":params.id,"adapter_argv":params.adapter_argv,"pid":params.pid,
"wait_for":params.wait_for,"attach_commands":params.attach_commands,
"started_stopped":params.started_stopped,"cwd":params.cwd,
"env":params.env,"timeout_ms":params.timeout_ms
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let identity = {
let mut processes = ProcessManager::with_store(store.clone());
let selection =
processes.select(&format!("pid:{}", params.pid))?;
if selection.processes.len() != 1 {
return Err(format!(
"PID {} did not resolve to one live process",
params.pid
));
}
selection.processes[0].clone()
};
let stable_target = format!(
"pid:{}@{}:{}",
identity.pid, identity.boot_id, identity.started_at_ns
);
let mut arguments = serde_json::json!({
"pid":params.pid,
"waitFor":params.wait_for,
"timeout":(params.timeout_ms / 1000).max(1)
});
if !params.attach_commands.is_empty() {
arguments["attachCommands"] =
serde_json::json!(params.attach_commands);
}
execute_dap_attach(
debugger,
executions,
store,
controller,
DapAttachExecutionInput {
id: params.id,
adapter_argv: params.adapter_argv,
stable_target,
attach_arguments: arguments,
started_stopped: params.started_stopped,
cwd: params.cwd,
env: params.env,
timeout_ms: params.timeout_ms,
idempotency_key: mutation_key,
},
)
.await
},
)
.await?,
)
}
DapRequestOperation::METHOD => {
let params = parse::<DapRequestOperation>(params)?;
if params.command.trim().is_empty() {
return Err("DAP request requires a command".to_string());
}
let material = serde_json::json!({
"id":params.id,"command":params.command,"arguments":params.arguments,
"timeout_ms":params.timeout_ms
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.dap_request(
¶ms.id,
¶ms.command,
params.arguments,
Duration::from_millis(params.timeout_ms.clamp(1, 120_000)),
)
.await
},
)
.await?,
)
}
DapStateOperation::METHOD => {
let params = parse::<DapStateOperation>(params)?;
json(self.debugger.dap_state(¶ms.id).await?)
}
DapThreadsOperation::METHOD => {
let params = parse::<DapThreadsOperation>(params)?;
json(self.debugger.dap_threads(¶ms.id).await?)
}
DapModulesOperation::METHOD => {
let params = parse::<DapModulesOperation>(params)?;
json(self.debugger.dap_modules(¶ms.id).await?)
}
DapRegistersOperation::METHOD => {
let params = parse::<DapRegistersOperation>(params)?;
json(self.debugger.dap_registers(¶ms.id).await?)
}
DapMemoryOperation::METHOD => {
let params = parse::<DapMemoryOperation>(params)?;
json(
self.debugger
.dap_memory(¶ms.id, ¶ms.address, params.count)
.await?,
)
}
DapDisassembleOperation::METHOD => {
let params = parse::<DapDisassembleOperation>(params)?;
json(
self.debugger
.dap_disassemble(¶ms.id, ¶ms.address, params.count)
.await?,
)
}
DapSignalsOperation::METHOD => {
let params = parse::<DapSignalsOperation>(params)?;
json(self.debugger.dap_signals(¶ms.id).await?)
}
DapWatchpointsOperation::METHOD => {
let params = parse::<DapWatchpointsOperation>(params)?;
json(self.debugger.dap_watchpoints(¶ms.id).await?)
}
RrRecordOperation::METHOD => {
let params = parse::<RrRecordOperation>(params)?;
if params.command.is_empty() {
return Err("rr record requires exact command argv".to_string());
}
let material = serde_json::json!({
"id":"rr-record","name":params.name,"command":params.command,
"rr_executable":params.rr_executable,"backend":params.backend,
"cwd":params.cwd,"env":params.env
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let trace = debugger
.rr_prepare_record(params.name, params.command.clone())?;
let mut env = params.env;
let (argv, backend) = match params.backend {
RrBackend::Native => {
env.insert(
"_RR_TRACE_DIR".to_string(),
debugger
.rr_recording_parent(&trace.id)
.to_string_lossy()
.into_owned(),
);
let mut argv = vec![
params.rr_executable,
"record".to_string(),
"--".to_string(),
];
argv.extend(params.command);
(argv, ExecutionBackendSpec::Native)
}
RrBackend::Isolated { image } => {
let guest_trace =
format!("/workspace/.apoc-rr-{}", trace.id);
env.insert("HOME".to_string(), "/home/sandbox".to_string());
let mut argv = vec![
isolated_rr_executable(params.rr_executable),
"record".to_string(),
"-W".to_string(),
"-n".to_string(),
"-o".to_string(),
guest_trace.clone(),
"--".to_string(),
];
argv.extend(params.command);
(
argv,
isolated_rr_backend(
image,
Some("/workspace".to_string()),
vec![ExecutionExportSpec {
source: guest_trace,
destination: "rr-trace".to_string(),
when: ExecutionExportWhen::Success,
}],
),
)
}
};
let mut spec = rr_execution_spec(RrExecutionSpecInput {
name: format!("rr/record/{}", trace.id),
purpose: "Record an rr trace under apoc execution ownership",
idempotency_key: format!("{mutation_key}/execution"),
argv,
cwd: params.cwd,
env,
io: IoMode::Pipes,
backend,
trace_id: &trace.id,
});
if let Err(error) =
normalize_execution_workspace(&mut spec, &controller)
{
let _ = debugger.rr_finish_record(
&trace.id,
false,
Some(error.clone()),
);
return Err(error);
}
let cwd = spec.workspace.cwd.clone();
if let Err(error) = bind_profile(
&store,
cwd.as_deref(),
None,
parent_profile_binding(
&store,
controller.execution_id.as_deref(),
&controller,
)?
.as_ref(),
&mut spec,
) {
let _ = debugger.rr_finish_record(
&trace.id,
false,
Some(error.clone()),
);
return Err(error);
}
let execution = match executions
.start(spec, controller, None, Some(format!("rr:{}", trace.id)))
.await
{
Ok(execution) => execution,
Err(error) => {
let _ = debugger.rr_finish_record(
&trace.id,
false,
Some(error.clone()),
);
return Err(error);
}
};
let trace =
debugger.rr_set_execution(&trace.id, execution.id.clone())?;
spawn_rr_finalizer(
debugger,
executions,
trace.id.clone(),
execution.id.clone(),
);
Ok(RrExecutionResult { trace, execution })
},
)
.await?,
)
}
RrReplayOperation::METHOD => {
let params = parse::<RrReplayOperation>(params)?;
let material = serde_json::json!({
"id":params.trace_id,"rr_executable":params.rr_executable,
"backend":params.backend,
"event":params.event,"pid":params.pid,"end":params.end
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let trace = debugger.rr_show(¶ms.trace_id)?;
let trace_dir = trace.trace_dir.clone().ok_or_else(|| {
format!("rr trace \"{}\" has no replay artifact", trace.id)
})?;
if !Path::new(&trace_dir).is_dir() {
return Err(format!(
"Managed rr trace directory is missing: {trace_dir}"
));
}
let (mut argv, cwd, env, backend, trace_path) = match params.backend
{
RrBackend::Native => (
vec![params.rr_executable, "replay".to_string()],
None,
BTreeMap::new(),
ExecutionBackendSpec::Native,
trace_dir,
),
RrBackend::Isolated { image } => {
let mut env = BTreeMap::new();
env.insert("HOME".to_string(), "/home/sandbox".to_string());
(
vec![
isolated_rr_executable(params.rr_executable),
"replay".to_string(),
"-W".to_string(),
],
Some(trace_dir),
env,
isolated_rr_backend(
image,
Some("/workspace".to_string()),
Vec::new(),
),
"/workspace".to_string(),
)
}
};
if let Some(event) = params.event {
argv.extend(["-g".to_string(), event.to_string()]);
}
if let Some(pid) = params.pid {
argv.extend(["-p".to_string(), pid.to_string()]);
}
if params.end {
argv.push("-e".to_string());
}
argv.push(trace_path);
let mut spec = rr_execution_spec(RrExecutionSpecInput {
name: format!("rr/replay/{}", trace.id),
purpose: "Replay an rr trace under apoc execution ownership",
idempotency_key: format!("{mutation_key}/execution"),
argv,
cwd,
env,
io: IoMode::Pty,
backend,
trace_id: &trace.id,
});
normalize_execution_workspace(&mut spec, &controller)?;
let cwd = spec.workspace.cwd.clone();
bind_profile(
&store,
cwd.as_deref(),
None,
parent_profile_binding(
&store,
controller.execution_id.as_deref(),
&controller,
)?
.as_ref(),
&mut spec,
)?;
let execution = executions
.start(spec, controller, None, Some(format!("rr:{}", trace.id)))
.await?;
let trace = debugger
.rr_set_replay_execution(&trace.id, execution.id.clone())?;
Ok(RrExecutionResult { trace, execution })
},
)
.await?,
)
}
RrProcessStatusOperation::METHOD => {
let params = parse::<RrProcessStatusOperation>(params)?;
let material = serde_json::json!({
"id":params.trace_id,"rr_executable":params.rr_executable,
"backend":params.backend
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let trace = debugger.rr_show(¶ms.trace_id)?;
let trace_dir = trace.trace_dir.clone().ok_or_else(|| {
format!("rr trace \"{}\" has no process data", trace.id)
})?;
let (cwd, env, backend, trace_path) = match params.backend {
RrBackend::Native => (
None,
BTreeMap::new(),
ExecutionBackendSpec::Native,
trace_dir,
),
RrBackend::Isolated { image } => {
let mut env = BTreeMap::new();
env.insert(
"HOME".to_string(),
"/home/sandbox".to_string(),
);
(
Some(trace_dir),
env,
isolated_rr_backend(
image,
Some("/workspace".to_string()),
Vec::new(),
),
"/workspace".to_string(),
)
}
};
let mut spec = rr_execution_spec(RrExecutionSpecInput {
name: format!("rr/ps/{}", trace.id),
purpose:
"Read rr trace process status under apoc execution ownership",
idempotency_key: format!("{mutation_key}/execution"),
argv: vec![
match &backend {
ExecutionBackendSpec::Isolated { .. } => {
isolated_rr_executable(params.rr_executable)
}
_ => params.rr_executable,
},
"ps".to_string(),
trace_path,
],
cwd,
env,
io: IoMode::Pipes,
backend,
trace_id: &trace.id,
});
normalize_execution_workspace(&mut spec, &controller)?;
let cwd = spec.workspace.cwd.clone();
bind_profile(
&store,
cwd.as_deref(),
None,
parent_profile_binding(&store, controller.execution_id.as_deref(), &controller)?.as_ref(),
&mut spec,
)?;
let execution = executions
.start(spec, controller, None, Some(format!("rr:{}", trace.id)))
.await?;
let execution = executions.wait(&execution.id, None).await?;
let logs = executions.logs(&execution.id, 32 * 1024)?;
Ok(RrProcessStatus {
trace,
execution,
logs,
})
},
)
.await?,
)
}
RrImportOperation::METHOD => {
let params = parse::<RrImportOperation>(params)?;
let material = serde_json::json!({
"id":"rr-import","path":params.path,"name":params.name
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.rr_import(¶ms.path, params.name) },
)
.await?,
)
}
RrListOperation::METHOD => json(self.debugger.rr_list()?),
RrShowOperation::METHOD => {
let params = parse::<RrShowOperation>(params)?;
json(self.debugger.rr_show(¶ms.trace_id)?)
}
DebuggerRunOperation::METHOD => {
let params = parse::<DebuggerRunOperation>(params)?;
if params.argv.is_empty() {
return Err("debugger.run requires exact command argv".to_string());
}
let material = serde_json::json!({
"id": params.id,
"host": params.host,
"port": params.port,
"argv": params.argv,
"cwd": params.cwd,
"env": params.env,
"timeout_ms": params.timeout_ms
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let store = self.store.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let mut argv = params.argv;
let executable = Path::new(&argv[0])
.file_name()
.and_then(|name| name.to_str())
.unwrap_or(&argv[0]);
if executable == "node"
&& !argv.iter().skip(1).any(|argument| {
argument == "--inspect"
|| argument == "--inspect-brk"
|| argument.starts_with("--inspect=")
|| argument.starts_with("--inspect-brk=")
})
{
argv.insert(
1,
format!("--inspect-brk={}:{}", params.host, params.port),
);
}
let mut labels = BTreeMap::new();
labels.insert("apoc.debugger_session".to_string(), params.id.clone());
let mut spec = ExecutionSpec {
schema_version: SCHEMA_VERSION,
idempotency_key: Some(format!("{mutation_key}/execution")),
name: format!("debugger/{}", params.id),
purpose: Some("Run an apoc-owned debugger target".to_string()),
labels,
program: ExecutionProgram::Command {
argv,
shell: false,
},
backend: ExecutionBackendSpec::Native,
workspace: WorkspaceContext {
cwd: params.cwd,
..WorkspaceContext::default()
},
env: params.env,
secrets: BTreeMap::new(),
profile_selection: None,
io: IoMode::Pipes,
owner_kind: LeaseOwnerKind::Persistent,
owner_id: None,
expires_at: None,
retry: RetryPolicy::default(),
budget: ExecutionBudget::default(),
telemetry: TelemetryPolicy::default(),
expect: None,
};
normalize_execution_workspace(&mut spec, &controller)?;
let cwd = spec.workspace.cwd.clone();
bind_profile(
&store,
cwd.as_deref(),
None,
parent_profile_binding(&store, controller.execution_id.as_deref(), &controller)?.as_ref(),
&mut spec,
)?;
let execution = executions
.start(
spec,
controller,
None,
Some(params.id.clone()),
)
.await?;
let deadline = tokio::time::Instant::now()
+ Duration::from_millis(params.timeout_ms);
loop {
if discover_targets(¶ms.host, params.port)
.await
.is_ok_and(|targets| !targets.is_empty())
{
break;
}
if tokio::time::Instant::now() >= deadline {
return Err(format!(
"Timed out discovering debugger target for execution {}",
execution.id
));
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
let session = debugger
.open(
params.id,
params.host,
params.port,
None,
Some(execution.id.clone()),
)
.await?;
Ok(DebuggerRunResult { execution, session })
},
)
.await?,
)
}
DebuggerOpenOperation::METHOD => {
let params = parse::<DebuggerOpenOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"host": params.host,
"port": params.port,
"target_id": params.target_id,
"execution_id": params.execution_id
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.open(
params.id,
params.host,
params.port,
params.target_id,
params.execution_id,
)
.await
},
)
.await?,
)
}
DebuggerStatusOperation::METHOD => {
let params = parse::<DebuggerStatusOperation>(params)?;
json(self.debugger.status(¶ms.id).await?)
}
DebuggerListOperation::METHOD => {
parse::<DebuggerListOperation>(params)?;
json(self.debugger.list()?)
}
DebuggerSelectedOperation::METHOD => {
parse::<DebuggerSelectedOperation>(params)?;
json(self.debugger.selected(&controller.actor)?)
}
DebuggerSelectOperation::METHOD => {
let params = parse::<DebuggerSelectOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"actor": controller.actor
});
let debugger = self.debugger.clone();
let actor = controller.actor.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.select(actor, ¶ms.id) },
)
.await?,
)
}
DebuggerTargetsOperation::METHOD => {
let params = parse::<DebuggerTargetsOperation>(params)?;
json(discover_targets(¶ms.host, params.port).await?)
}
DebuggerEventsOperation::METHOD => {
let params = parse::<DebuggerEventsOperation>(params)?;
json(
self.debugger
.events(¶ms.id, params.after, params.limit)?,
)
}
DebuggerStackOperation::METHOD => {
let params = parse::<DebuggerStackOperation>(params)?;
json(self.debugger.stack(¶ms.id).await?)
}
DebuggerScopesOperation::METHOD => {
let params = parse::<DebuggerScopesOperation>(params)?;
json(self.debugger.scopes(¶ms.id, params.frame).await?)
}
DebuggerVariablesOperation::METHOD => {
let params = parse::<DebuggerVariablesOperation>(params)?;
json(self.debugger.variables(¶ms.id, params.frame).await?)
}
DebuggerPropertiesOperation::METHOD => {
let params = parse::<DebuggerPropertiesOperation>(params)?;
json(
self.debugger
.properties(¶ms.id, ¶ms.object_id)
.await?,
)
}
DebuggerPrototypesOperation::METHOD => {
let params = parse::<DebuggerPrototypesOperation>(params)?;
json(
self.debugger
.prototypes(¶ms.id, ¶ms.object_id, params.limit)
.await?,
)
}
DebuggerListenersOperation::METHOD => {
let params = parse::<DebuggerListenersOperation>(params)?;
json(
self.debugger
.listeners(¶ms.id, ¶ms.object_id)
.await?,
)
}
DebuggerThisOperation::METHOD => {
let params = parse::<DebuggerThisOperation>(params)?;
json(
self.debugger
.this_properties(¶ms.id, params.frame)
.await?,
)
}
DebuggerSourceOperation::METHOD => {
let params = parse::<DebuggerSourceOperation>(params)?;
json(
self.debugger
.source(
¶ms.id,
params.script_id.as_deref(),
params.file.as_deref(),
params.from_line,
params.to_line,
)
.await?,
)
}
DebuggerScriptsOperation::METHOD => {
let params = parse::<DebuggerScriptsOperation>(params)?;
json(self.debugger.scripts(¶ms.id).await?)
}
DebuggerConsoleOperation::METHOD => {
let params = parse::<DebuggerConsoleOperation>(params)?;
json(self.debugger.console(¶ms.id).await?)
}
DebuggerExceptionsOperation::METHOD => {
let params = parse::<DebuggerExceptionsOperation>(params)?;
json(self.debugger.exceptions(¶ms.id).await?)
}
DebuggerHealthOperation::METHOD => {
let params = parse::<DebuggerHealthOperation>(params)?;
json(self.debugger.health(¶ms.id).await?)
}
DebuggerTraceOperation::METHOD => {
let params = parse::<DebuggerTraceOperation>(params)?;
json(
self.debugger
.trace(¶ms.id, params.after, params.limit)
.await?,
)
}
DebuggerPauseOperation::METHOD => {
let params = parse::<DebuggerPauseOperation>(params)?;
let material =
serde_json::json!({"id": params.id, "timeout_ms": params.timeout_ms});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.pause(¶ms.id, Duration::from_millis(params.timeout_ms))
.await
},
)
.await?,
)
}
DebuggerResumeOperation::METHOD => {
let params = parse::<DebuggerResumeOperation>(params)?;
let material = serde_json::json!({"id": params.id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.resume(¶ms.id).await },
)
.await?,
)
}
DebuggerContinueOperation::METHOD => {
let params = parse::<DebuggerContinueOperation>(params)?;
let material =
serde_json::json!({"id": params.id, "timeout_ms": params.timeout_ms});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.continue_to_pause(
¶ms.id,
Duration::from_millis(params.timeout_ms),
)
.await
},
)
.await?,
)
}
DebuggerStepOperation::METHOD => {
let params = parse::<DebuggerStepOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"kind": params.kind,
"timeout_ms": params.timeout_ms
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.step(
¶ms.id,
¶ms.kind,
Duration::from_millis(params.timeout_ms),
)
.await
},
)
.await?,
)
}
DebuggerReconnectOperation::METHOD => {
let params = parse::<DebuggerReconnectOperation>(params)?;
let material = serde_json::json!({"id": params.id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.reconnect(¶ms.id).await },
)
.await?,
)
}
DebuggerRestartOperation::METHOD => {
let params = parse::<DebuggerRestartOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"timeout_ms": params.timeout_ms
});
let debugger = self.debugger.clone();
let executions = self.executions.clone();
let controller = controller.clone();
let mutation_key = params.idempotency_key.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
let record = debugger.record(¶ms.id)?;
let host = record.host.ok_or_else(|| {
"Debugger session has no reconnectable host".to_string()
})?;
let port = record.port.ok_or_else(|| {
"Debugger session has no reconnectable port".to_string()
})?;
let execution_id = record.execution_id.ok_or_else(|| {
"Debugger restart requires a linked apoc execution".to_string()
})?;
let execution = executions.get(&execution_id)?;
debugger.disconnect_live(¶ms.id).await;
executions
.cancel_unclaimed(
&execution_id,
Duration::from_millis(params.timeout_ms),
&controller,
)
.await?;
let mut spec = execution.spec;
spec.idempotency_key = Some(format!("{mutation_key}/execution"));
spec.name = format!("debugger/{}", params.id);
spec.owner_kind = LeaseOwnerKind::Persistent;
spec.owner_id = None;
let replacement = executions
.start(
spec,
controller,
None,
Some(params.id.clone()),
)
.await?;
let deadline = tokio::time::Instant::now()
+ Duration::from_millis(params.timeout_ms);
loop {
if discover_targets(&host, port)
.await
.is_ok_and(|targets| !targets.is_empty())
{
break;
}
if tokio::time::Instant::now() >= deadline {
return Err(format!(
"Timed out discovering restarted debugger target for execution {}",
replacement.id
));
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
let session = debugger
.open(
params.id,
host,
port,
None,
Some(replacement.id.clone()),
)
.await?;
Ok(DebuggerRunResult {
execution: replacement,
session,
})
},
)
.await?,
)
}
DebuggerBreakpointSetOperation::METHOD => {
let params = parse::<DebuggerBreakpointSetOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"file": params.file,
"line": params.line,
"condition": params.condition
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.set_breakpoint(
¶ms.id,
params.file,
params.line,
params.condition,
)
.await
},
)
.await?,
)
}
DebuggerBreakpointListOperation::METHOD => {
let params = parse::<DebuggerBreakpointListOperation>(params)?;
json(self.debugger.list_breakpoints(¶ms.id)?)
}
DebuggerBreakpointDeleteOperation::METHOD => {
let params = parse::<DebuggerBreakpointDeleteOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"breakpoint_id": params.breakpoint_id
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.delete_breakpoint(¶ms.id, ¶ms.breakpoint_id)
.await
},
)
.await?,
)
}
DebuggerTapAddOperation::METHOD => {
let params = parse::<DebuggerTapAddOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"file":params.file,"line":params.line,
"expression":params.expression,"url_regex":params.url_regex
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.tap_add(
¶ms.id,
params.file,
params.line,
params.expression,
params.url_regex,
)
.await
},
)
.await?,
)
}
DebuggerTapListOperation::METHOD => {
let params = parse::<DebuggerTapListOperation>(params)?;
json(self.debugger.tap_list(¶ms.id)?)
}
DebuggerTapHitsOperation::METHOD => {
let params = parse::<DebuggerTapHitsOperation>(params)?;
json(
self.debugger
.tap_hits(¶ms.id, ¶ms.tap_id, params.limit)?,
)
}
DebuggerTapRemoveOperation::METHOD => {
let params = parse::<DebuggerTapRemoveOperation>(params)?;
let material = serde_json::json!({"id":params.id,"tap_id":params.tap_id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.tap_remove(¶ms.id, ¶ms.tap_id).await
},
)
.await?,
)
}
DebuggerWatchAddOperation::METHOD => {
let params = parse::<DebuggerWatchAddOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"target":params.target,
"expression":params.expression,"access":params.access
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.watch_add(
¶ms.id,
params.target,
params.expression,
params.access,
)
.await
},
)
.await?,
)
}
DebuggerWatchListOperation::METHOD => {
let params = parse::<DebuggerWatchListOperation>(params)?;
json(self.debugger.watch_list(¶ms.id)?)
}
DebuggerWatchHitsOperation::METHOD => {
let params = parse::<DebuggerWatchHitsOperation>(params)?;
json(
self.debugger
.watch_hits(¶ms.id, ¶ms.watch_id, params.limit)?,
)
}
DebuggerWatchRemoveOperation::METHOD => {
let params = parse::<DebuggerWatchRemoveOperation>(params)?;
let material = serde_json::json!({"id":params.id,"watch_id":params.watch_id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.watch_remove(¶ms.id, ¶ms.watch_id).await
},
)
.await?,
)
}
DebuggerEvaluateOperation::METHOD => {
let params = parse::<DebuggerEvaluateOperation>(params)?;
let material = serde_json::json!({
"id": params.id,
"expression": params.expression,
"frame": params.frame
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.evaluate(¶ms.id, params.expression, params.frame)
.await
},
)
.await?,
)
}
DebuggerCloseOperation::METHOD => {
let params = parse::<DebuggerCloseOperation>(params)?;
let material = serde_json::json!({"id": params.id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.close(¶ms.id).await },
)
.await?,
)
}
DebuggerBrowserStateOperation::METHOD => {
let params = parse::<DebuggerBrowserStateOperation>(params)?;
json(self.debugger.browser_state(¶ms.id).await?)
}
DebuggerBrowserNetworkOperation::METHOD => {
let params = parse::<DebuggerBrowserNetworkOperation>(params)?;
json(self.debugger.browser_network(¶ms.id).await?)
}
DebuggerBrowserWebSocketsOperation::METHOD => {
let params = parse::<DebuggerBrowserWebSocketsOperation>(params)?;
json(self.debugger.browser_websocket_frames(¶ms.id).await?)
}
DebuggerBrowserPageEventsOperation::METHOD => {
let params = parse::<DebuggerBrowserPageEventsOperation>(params)?;
json(self.debugger.browser_page_events(¶ms.id).await?)
}
DebuggerBrowserDomOperation::METHOD => {
let params = parse::<DebuggerBrowserDomOperation>(params)?;
json(
self.debugger
.browser_dom(¶ms.id, ¶ms.selector)
.await?,
)
}
DebuggerBrowserStylesOperation::METHOD => {
let params = parse::<DebuggerBrowserStylesOperation>(params)?;
json(
self.debugger
.browser_styles(¶ms.id, ¶ms.selector)
.await?,
)
}
DebuggerBrowserCookiesOperation::METHOD => {
let params = parse::<DebuggerBrowserCookiesOperation>(params)?;
json(self.debugger.browser_cookies(¶ms.id).await?)
}
DebuggerBrowserStorageOperation::METHOD => {
let params = parse::<DebuggerBrowserStorageOperation>(params)?;
json(
self.debugger
.browser_storage(¶ms.id, ¶ms.kind)
.await?,
)
}
DebuggerBrowserPerformanceOperation::METHOD => {
let params = parse::<DebuggerBrowserPerformanceOperation>(params)?;
json(self.debugger.browser_performance(¶ms.id).await?)
}
DebuggerBrowserNetworkBodyOperation::METHOD => {
let params = parse::<DebuggerBrowserNetworkBodyOperation>(params)?;
json(
self.debugger
.browser_network_body(¶ms.id, ¶ms.request_id)
.await?,
)
}
DebuggerBrowserNavigateOperation::METHOD => {
let params = parse::<DebuggerBrowserNavigateOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"action":params.action,"target":params.target,
"timeout_ms":params.timeout_ms
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.browser_navigate(
¶ms.id,
¶ms.action,
params.target.as_deref(),
Duration::from_millis(params.timeout_ms),
)
.await
},
)
.await?,
)
}
DebuggerBrowserScreenshotOperation::METHOD => {
let params = parse::<DebuggerBrowserScreenshotOperation>(params)?;
let viewport = match (params.width, params.height) {
(Some(width), Some(height)) => Some((width, height)),
(None, None) => None,
_ => return Err("Browser viewport requires both width and height".to_string()),
};
let material = serde_json::json!({
"id":params.id,"selector":params.selector,"full_page":params.full_page,
"viewport":viewport,"state":params.state,"inline":params.inline
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.browser_screenshot(
¶ms.id,
params.selector.as_deref(),
params.full_page,
viewport,
params.state.as_deref(),
params.inline,
)
.await
},
)
.await?,
)
}
DebuggerBrowserClickOperation::METHOD => {
let params = parse::<DebuggerBrowserClickOperation>(params)?;
let material = serde_json::json!({"id":params.id,"selector":params.selector});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.browser_click(¶ms.id, ¶ms.selector).await
},
)
.await?,
)
}
DebuggerBrowserTypeOperation::METHOD | DebuggerBrowserSelectOperation::METHOD => {
let (id, selector, value, idempotency_key) =
if method == DebuggerBrowserTypeOperation::METHOD {
let params = parse::<DebuggerBrowserTypeOperation>(params)?;
(
params.id,
params.selector,
params.value,
params.idempotency_key,
)
} else {
let params = parse::<DebuggerBrowserSelectOperation>(params)?;
(
params.id,
params.selector,
params.value,
params.idempotency_key,
)
};
let material = serde_json::json!({
"id":id,"selector":selector,"value":value
});
let debugger = self.debugger.clone();
let operation = method.to_string();
json(
self.debugger
.mutation(idempotency_key, method, material, move || async move {
if operation.ends_with(".type") {
debugger.browser_type(&id, &selector, &value).await
} else {
debugger.browser_select(&id, &selector, &value).await
}
})
.await?,
)
}
DebuggerBrowserMockOperation::METHOD => {
let params = parse::<DebuggerBrowserMockOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"pattern":params.pattern,"body":params.body,
"status":params.status,"headers":params.headers
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.browser_mock(
¶ms.id,
params.pattern,
params.body,
params.status,
params.headers,
)
.await
},
)
.await?,
)
}
DebuggerBrowserUnmockOperation::METHOD => {
let params = parse::<DebuggerBrowserUnmockOperation>(params)?;
let material = serde_json::json!({"id":params.id,"pattern":params.pattern});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.browser_unmock(¶ms.id, params.pattern.as_deref())
.await
},
)
.await?,
)
}
DebuggerBrowserEmulateOperation::METHOD | DebuggerBrowserThrottleOperation::METHOD => {
let (id, preset, idempotency_key) =
if method == DebuggerBrowserEmulateOperation::METHOD {
let params = parse::<DebuggerBrowserEmulateOperation>(params)?;
(params.id, params.preset, params.idempotency_key)
} else {
let params = parse::<DebuggerBrowserThrottleOperation>(params)?;
(params.id, params.preset, params.idempotency_key)
};
let material = serde_json::json!({"id":id,"preset":preset});
let debugger = self.debugger.clone();
let operation = method.to_string();
json(
self.debugger
.mutation(idempotency_key, method, material, move || async move {
if operation.ends_with(".emulate") {
debugger.browser_emulate(&id, &preset).await
} else {
debugger.browser_throttle(&id, &preset).await
}
})
.await?,
)
}
DebuggerBrowserCoverageOperation::METHOD => {
let params = parse::<DebuggerBrowserCoverageOperation>(params)?;
let material = serde_json::json!({"id":params.id,"action":params.preset});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
match params.preset.as_str() {
"start" => {
debugger.browser_coverage_start(¶ms.id).await?;
Ok(crate::debugger::BrowserCoverageSnapshot {
captured_at: now_ms(),
entries: Vec::new(),
})
}
"stop" => debugger.browser_coverage_stop(¶ms.id).await,
other => {
Err(format!("Unknown browser coverage action \"{other}\""))
}
}
},
)
.await?,
)
}
DebuggerRecordingStatusOperation::METHOD => {
let params = parse::<DebuggerRecordingStatusOperation>(params)?;
json(self.debugger.recording_status(¶ms.id)?)
}
DebuggerRecordingListOperation::METHOD => {
let _params = parse::<DebuggerRecordingListOperation>(params)?;
json(self.debugger.recording_list()?)
}
DebuggerRecordingCapturesOperation::METHOD => {
let params = parse::<DebuggerRecordingCapturesOperation>(params)?;
json(self.debugger.recording_captures(¶ms.recording_id)?)
}
DebuggerRecordingMarksOperation::METHOD => {
let params = parse::<DebuggerRecordingMarksOperation>(params)?;
json(self.debugger.recording_marks(¶ms.recording_id)?)
}
DebuggerRecordingAftersOperation::METHOD => {
let params = parse::<DebuggerRecordingAftersOperation>(params)?;
json(self.store.debugger_afters(¶ms.recording_id)?)
}
DebuggerRecordingAfterGetOperation::METHOD => {
let params = parse::<DebuggerRecordingAfterGetOperation>(params)?;
json(self.store.debugger_after(¶ms.id)?)
}
DebuggerRecordingWhyOperation::METHOD => {
let params = parse::<DebuggerRecordingWhyOperation>(params)?;
json(self.debugger.recording_why(
¶ms.id,
controller.cwd.as_deref(),
params.substring.as_deref(),
params.window_ms,
)?)
}
DebuggerRecordingStartOperation::METHOD => {
let params = parse::<DebuggerRecordingStartOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"max_frames":params.max_frames,"max_bytes":params.max_bytes
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.recording_start(
¶ms.id,
params.max_frames,
params.max_bytes,
)
.await
},
)
.await?,
)
}
DebuggerRecordingCaptureOperation::METHOD | DebuggerRecordingShootOperation::METHOD => {
let (id, reason, idempotency_key) =
if method == DebuggerRecordingCaptureOperation::METHOD {
let params = parse::<DebuggerRecordingCaptureOperation>(params)?;
(params.id, params.reason, params.idempotency_key)
} else {
let params = parse::<DebuggerRecordingShootOperation>(params)?;
(params.id, params.reason, params.idempotency_key)
};
let material = serde_json::json!({"id":id,"reason":reason});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(idempotency_key, method, material, move || async move {
debugger.recording_capture(&id, reason).await
})
.await?,
)
}
DebuggerRecordingMarkOperation::METHOD => {
let params = parse::<DebuggerRecordingMarkOperation>(params)?;
let material = serde_json::json!({"id":params.id,"name":params.name});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.recording_mark(¶ms.id, params.name).await
},
)
.await?,
)
}
DebuggerRecordingCorrelateOperation::METHOD => {
let params = parse::<DebuggerRecordingCorrelateOperation>(params)?;
let path = params
.path
.as_deref()
.map(|path| resolve_controller_path(controller, path, "recording edit path"))
.transpose()?
.map(|path| path.display().to_string());
let material = serde_json::json!({
"id":params.id,
"kind":params.kind,
"reference":params.reference,
"path":path,
"at":params.at
});
let debugger = self.debugger.clone();
let actor = controller.actor.clone();
let causation_id = controller.invocation_id.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.recording_correlate(DebuggerRecordingCorrelation {
session_id: params.id,
kind: params.kind,
reference: params.reference,
path,
at: params.at,
actor,
causation_id,
})
},
)
.await?,
)
}
DebuggerRecordingAfterOperation::METHOD => {
let params = parse::<DebuggerRecordingAfterOperation>(params)?;
let material = serde_json::json!({"id":params.id,"anchor":params.anchor});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.recording_after(¶ms.id, params.anchor.as_deref())
.await
},
)
.await?,
)
}
DebuggerRecordingTimelineOperation::METHOD => {
let params = parse::<DebuggerRecordingTimelineOperation>(params)?;
let cwd = controller.cwd.clone();
let material = serde_json::json!({
"id":params.id,"limit":params.limit,"cwd":cwd
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.recording_timeline(
¶ms.id,
cwd.as_deref(),
params.limit,
)
},
)
.await?,
)
}
DebuggerRecordingStopOperation::METHOD => {
let params = parse::<DebuggerRecordingStopOperation>(params)?;
let material = serde_json::json!({"id":params.id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.recording_stop(¶ms.id).await },
)
.await?,
)
}
DebuggerRecordingReplayOperation::METHOD => {
let params = parse::<DebuggerRecordingReplayOperation>(params)?;
let material = serde_json::json!({"id":params.id,"capture_id":params.capture_id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.recording_replay(
¶ms.id,
¶ms.capture_id,
Duration::from_millis(params.timeout_ms),
)
.await
},
)
.await?,
)
}
DebuggerFlowListOperation::METHOD => {
let _params = parse::<DebuggerFlowListOperation>(params)?;
json(self.debugger.flow_list()?)
}
DebuggerFlowShowOperation::METHOD => {
let params = parse::<DebuggerFlowShowOperation>(params)?;
json(self.debugger.flow_show(¶ms.id, ¶ms.name)?)
}
DebuggerFlowRecordOperation::METHOD => {
let params = parse::<DebuggerFlowRecordOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"name":params.name,"url":params.url
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.flow_record(¶ms.id, params.name, params.url)
.await
},
)
.await?,
)
}
DebuggerFlowStopOperation::METHOD => {
let params = parse::<DebuggerFlowStopOperation>(params)?;
let material = serde_json::json!({"id":params.id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.flow_stop(¶ms.id).await },
)
.await?,
)
}
DebuggerFlowRunOperation::METHOD => {
let params = parse::<DebuggerFlowRunOperation>(params)?;
let material = serde_json::json!({
"id":params.id,"name":params.name,"step_timeout_ms":params.step_timeout_ms
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.flow_run(
¶ms.id,
¶ms.name,
Duration::from_millis(params.step_timeout_ms),
)
.await
},
)
.await?,
)
}
DebuggerEvidenceTraceStartOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceStartOperation>(params)?;
let material = serde_json::json!({"id":params.id,"name":params.name});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.evidence_trace_start(¶ms.id, params.name).await
},
)
.await?,
)
}
DebuggerEvidenceTraceStopOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceStopOperation>(params)?;
let material = serde_json::json!({"id":params.id});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.evidence_trace_stop(¶ms.id) },
)
.await?,
)
}
DebuggerEvidenceTraceListOperation::METHOD => {
let _params = parse::<DebuggerEvidenceTraceListOperation>(params)?;
json(self.debugger.evidence_trace_list()?)
}
DebuggerEvidenceTraceShowOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceShowOperation>(params)?;
json(self.debugger.evidence_trace_show(¶ms.trace_id)?)
}
DebuggerEvidenceTraceUseOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceUseOperation>(params)?;
let material = serde_json::json!({
"id":"debugger-evidence-trace","trace_id":params.trace_id,
"actor":controller.actor
});
let debugger = self.debugger.clone();
let actor = controller.actor.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger.evidence_trace_use(actor, ¶ms.trace_id)
},
)
.await?,
)
}
DebuggerEvidenceTraceReplayOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceReplayOperation>(params)?;
let material = serde_json::json!({
"id":"debugger-evidence-trace","trace_id":params.trace_id,
"at":params.at,"actor":controller.actor
});
let debugger = self.debugger.clone();
let actor = controller.actor.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move {
debugger
.evidence_trace_replay(
actor,
¶ms.trace_id,
params.at.as_deref(),
)
.await
},
)
.await?,
)
}
DebuggerEvidenceTraceExportOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceExportOperation>(params)?;
let material = serde_json::json!({
"id":"debugger-evidence-trace","trace_id":params.trace_id
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.evidence_trace_export(¶ms.trace_id) },
)
.await?,
)
}
DebuggerEvidenceTraceImportOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceImportOperation>(params)?;
let material = serde_json::json!({
"id":"debugger-evidence-trace-import","path":params.path
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.evidence_trace_import(¶ms.path) },
)
.await?,
)
}
DebuggerEvidenceTraceGcOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceGcOperation>(params)?;
let material = serde_json::json!({
"id":"debugger-evidence-trace-gc","keep":params.keep
});
let debugger = self.debugger.clone();
json(
self.debugger
.mutation(
params.idempotency_key,
method,
material,
move || async move { debugger.evidence_trace_gc(params.keep) },
)
.await?,
)
}
DebuggerEvidenceTraceCursorOperation::METHOD => {
let params = parse::<DebuggerEvidenceTraceCursorOperation>(params)?;
json(
self.debugger
.evidence_trace_cursor(&controller.actor, params.trace_id.as_deref())?,
)
}
DebuggerEvidenceTraceMoveOperation::METHOD
| DebuggerEvidenceTraceJumpOperation::METHOD => {
let (direction, count, kind, idempotency_key) =
if method == DebuggerEvidenceTraceMoveOperation::METHOD {
let params = parse::<DebuggerEvidenceTraceMoveOperation>(params)?;
(
params.direction,
params.count,
params.kind,
params.idempotency_key,
)
} else {
let params = parse::<DebuggerEvidenceTraceJumpOperation>(params)?;
(
params.direction,
params.count,
params.kind,
params.idempotency_key,
)
};
let material = serde_json::json!({
"id":"debugger-evidence-trace-cursor","direction":direction,
"count":count,"kind":kind,"actor":controller.actor
});
let debugger = self.debugger.clone();
let actor = controller.actor.clone();
json(
self.debugger
.mutation(idempotency_key, method, material, move || async move {
debugger.evidence_trace_move(&actor, &direction, count, kind.as_deref())
})
.await?,
)
}
_ => Err(format!("Unknown daemon method \"{method}\"")),
}
}
fn status(&self) -> Result<DaemonStatus, String> {
let active_executions = self.store.active_execution_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,
gc: self.gc_status(),
})
}
async fn close_session(
&self,
id: &str,
timeout: Duration,
controller: &ProcessController,
) -> Result<AgentSession, String> {
let (mut session, began_closing) = self.store.begin_session_close(id)?;
if session.closed {
return Ok(session);
}
if began_closing {
self.lifecycle_event(
"session.closing",
&format!("session/{id}"),
controller,
None,
Some(id.to_string()),
serde_json::json!({}),
)?;
}
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 {
self.polls.notify_cancel(&execution)?;
self.executions
.cancel_unclaimed(&execution, timeout, controller)
.await?;
}
self.store.release_lease(&session_lease_id(id))?;
session.closing = false;
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.store.get_execution_record(&lease.owner_id)?.is_some() {
self.polls.notify_cancel(&lease.owner_id)?;
self.executions
.cancel_unclaimed(&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_expired_leases(now)?;
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),
}
}
}
async fn dispatch_hook_deliveries(self: &Arc<Self>) -> Result<(), String> {
let running = self.store.running_hook_delivery_count()?;
let available = self.code_workers.saturating_sub(running);
let deliveries = self.store.claim_hook_deliveries(available, now_ms())?;
for delivery in deliveries {
let daemon = Arc::clone(self);
tokio::spawn(async move {
daemon.run_hook_delivery(delivery).await;
});
}
Ok(())
}
async fn run_hook_delivery(self: Arc<Self>, delivery: HookDelivery) {
let mut controller = default_controller();
controller.invocation_id = delivery.id.clone();
controller.actor = "hook".to_string();
controller.agent = true;
controller.cwd = delivery.invocation.cwd.clone();
controller.hook_depth = 1;
let hook_context = serde_json::json!({
"delivery": {
"id": delivery.id,
"hook": delivery.hook_name,
"generation": delivery.hook_generation,
"phase": delivery.phase,
"attempt": delivery.attempts,
"max_attempts": delivery.max_attempts,
},
"invocation": delivery.invocation,
});
let context = match serde_json::to_string(&hook_context) {
Ok(context) => context,
Err(error) => {
let _ = self.store.finish_hook_delivery(
&delivery.id,
false,
Some(format!("HOOK_CONTEXT_ENCODE_FAILED: {error}")),
);
return;
}
};
let source = format!(
"const hook = Object.freeze({context});\n{}",
delivery.program
);
let origin = crate::code::RequestOrigin {
cwd: controller.cwd.clone(),
verbosity: Some(crate::model::Verbosity::Trace.as_str().to_string()),
profile_selection: None,
hook_depth: 1,
decider_depth: 0,
..Default::default()
};
let started = match self.code.read().await.start(source, origin).await {
Ok(state) => state,
Err(error) => {
let _ = self.store.finish_hook_delivery(
&delivery.id,
false,
Some(format!("HOOK_START_FAILED: {error}")),
);
return;
}
};
if let Err(error) = self
.store
.set_hook_delivery_execution(&delivery.id, &started.id)
{
let cancellation = self.code.read().await.cancel(started.id.clone()).await;
if let Ok(state) = &cancellation {
let _ = self.record_code_execution(state, &controller, None, None, None);
}
let error = match cancellation {
Ok(_) => format!("HOOK_EXECUTION_LINK_FAILED: {error}"),
Err(cancel_error) => format!(
"HOOK_EXECUTION_LINK_FAILED: {error}; HOOK_LINK_CANCEL_FAILED: {cancel_error}"
),
};
let _ = self.store.finish_hook_delivery_with_execution(
&delivery.id,
false,
Some(error),
Some(&started.id),
);
return;
}
if let Err(error) = self.record_code_execution(
&started,
&controller,
Some(&format!(
"Run hook {} for {}.",
delivery.hook_name, delivery.invocation_id
)),
None,
None,
) {
let _ = self.code.read().await.cancel(started.id.clone()).await;
let _ = self.store.finish_hook_delivery(
&delivery.id,
false,
Some(format!("HOOK_EXECUTION_RECORD_FAILED: {error}")),
);
return;
}
let _ = self.lifecycle_event(
"hook.delivery.started",
&format!("hook/{}/delivery/{}", delivery.hook_name, delivery.id),
&controller,
Some(started.id.clone()),
None,
serde_json::json!({
"hook": delivery.hook_name,
"phase": delivery.phase,
"invocation_id": delivery.invocation_id,
"attempt": delivery.attempts,
}),
);
let state = match self
.code
.read()
.await
.wait(
&started.id,
Some(Duration::from_millis(delivery.timeout_ms)),
)
.await
{
Ok(state) if !code_terminal(state.status) => {
match self.code.read().await.cancel(started.id.clone()).await {
Ok(state) => state,
Err(error) => {
let _ = self.store.finish_hook_delivery(
&delivery.id,
false,
Some(format!("HOOK_TIMEOUT_CANCEL_FAILED: {error}")),
);
return;
}
}
}
Ok(state) => state,
Err(error) => {
let _ = self.store.finish_hook_delivery(
&delivery.id,
false,
Some(format!("HOOK_WAIT_FAILED: {error}")),
);
return;
}
};
let _ = self.record_code_execution(&state, &controller, None, None, None);
let succeeded = state.status == CodeExecutionStatus::Completed;
let error = (!succeeded).then(|| {
state
.error
.clone()
.unwrap_or_else(|| format!("HOOK_EXECUTION_{:?}", state.status).to_uppercase())
});
let terminal = self
.store
.finish_hook_delivery(&delivery.id, succeeded, error)
.ok();
let _ = self.lifecycle_event(
"hook.delivery.result",
&format!("hook/{}/delivery/{}", delivery.hook_name, delivery.id),
&controller,
Some(state.id),
None,
serde_json::json!({
"hook": delivery.hook_name,
"phase": delivery.phase,
"invocation_id": delivery.invocation_id,
"status": terminal.map(|delivery| delivery.status),
}),
);
}
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>,
profile_selection: Option<&crate::model::ProfileSelection>,
telemetry: Option<&TelemetryPolicy>,
) -> 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()
});
if previous.is_none() {
crate::execution::enrich_workspace(&mut workspace);
}
let status = code_status(state.status);
let error_code = state
.error
.as_deref()
.map(code_execution_error_code)
.map(ToString::to_string);
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: error_code.clone(),
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,
},
backend: crate::model::ExecutionBackendSpec::default(),
workspace,
env: BTreeMap::new(),
secrets: BTreeMap::new(),
profile_selection: previous
.as_ref()
.and_then(|execution| execution.spec.profile_selection.clone())
.or_else(|| profile_selection.cloned()),
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(),
telemetry: previous
.as_ref()
.map(|execution| execution.spec.telemetry.clone())
.or_else(|| telemetry.cloned())
.unwrap_or_default(),
expect: None,
},
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": error_code,
"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::with_dispatch(self.store.clone(), self.dispatch.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 require_active_recording(
&self,
controller: &ProcessController,
scope: &RecordingScopeParams,
) -> Result<Recording, String> {
let (scope_kind, scope_key) =
selected_recipe_scope(controller, scope.global, scope.cwd.as_deref())?;
self.store
.active_recording_in_recipe_scope(scope_kind, scope_key.as_deref())?
.ok_or_else(|| "RECORDING_INACTIVE: No recording is capturing this scope".to_string())
}
fn recording_takes(
&self,
recording: &Recording,
) -> Result<Vec<Vec<crate::model::RecordingStep>>, String> {
let skipped = recording.skipped.iter().cloned().collect::<BTreeSet<_>>();
recording
.takes
.iter()
.map(|take| {
let records = self
.store
.recording_invocations(&recording.id, take.index)?;
Ok(crate::recording::transcribe(&records, take.index, &skipped))
})
.collect()
}
fn recording_evidence(
&self,
recording: &Recording,
) -> Result<Vec<RecipeEvidenceRange>, String> {
recording
.takes
.iter()
.filter_map(|take| {
let records = match self.store.recording_invocations(&recording.id, take.index) {
Ok(records) => records,
Err(error) => return Some(Err(error)),
};
let first = records.first()?;
let last = records.last()?;
Some(Ok(RecipeEvidenceRange {
start_id: first.id.clone(),
end_id: last.id.clone(),
invocation_ids: records.iter().map(|record| record.id.clone()).collect(),
}))
})
.collect()
}
fn recording_detail(&self, recording: Recording) -> Result<RecordingDetail, String> {
let steps = self
.recording_takes(&recording)?
.into_iter()
.flatten()
.collect();
Ok(RecordingDetail { recording, steps })
}
}
fn recording_params(recording: &Recording) -> Vec<RecordingParam> {
let mut params: Vec<RecordingParam> = Vec::new();
for take in &recording.takes {
for param in &take.params {
params.retain(|existing| existing.name != param.name);
params.push(param.clone());
}
}
params
}
fn validate_input_name(name: &str) -> Result<(), String> {
let valid = !name.is_empty()
&& !name.starts_with(|character: char| character.is_ascii_digit())
&& name
.chars()
.all(|character| character.is_ascii_alphanumeric() || character == '_');
if valid {
Ok(())
} else {
Err(format!(
"Parameter name \"{name}\" must be a JavaScript identifier"
))
}
}
fn required_profile_name(name: Option<&str>) -> Result<&str, String> {
let name = name.ok_or_else(|| "Profile name is required".to_string())?;
validate_profile_name(name)?;
Ok(name)
}
fn parent_profile_binding(
store: &Store,
parent_id: Option<&str>,
controller: &ProcessController,
) -> Result<Option<Option<ProfileSelection>>, String> {
let Some(parent_id) = parent_id else {
return Ok(None);
};
let stored = store
.get_execution_record(parent_id)?
.and_then(|execution| execution.spec.profile_selection);
Ok(Some(
stored.or_else(|| controller.profile_selection.clone()),
))
}
fn environment_profile_name(
store: &Store,
cwd: Option<&str>,
global: bool,
explicit: Option<&str>,
create_legacy_default: bool,
) -> Result<Option<String>, String> {
if global && explicit.is_some() {
return Err("--global and --profile cannot be used together".to_string());
}
if global {
if let Some(name) = store.default_profile()? {
return Ok(Some(name));
}
if create_legacy_default {
let name = "legacy-default";
if store.get_profile(name)?.is_none() {
store.put_profile(&Profile::empty(name))?;
}
store.set_default_profile(Some(name))?;
return Ok(Some(name.to_string()));
}
return Ok(None);
}
Ok(resolve_profile(store, cwd, explicit)?
.selection
.map(|selection| selection.name))
}
fn validate_provider_profile_config(store: &Store, config: &ConnectorConfig) -> Result<(), String> {
if config.profile_mode == ProfileMode::None
&& (!config.profile_env.is_empty() || !config.profile_headers.is_empty())
{
return Err(
"PROVIDER_PROFILE_MODE_INVALID: profile mappings require optional or required mode"
.to_string(),
);
}
if config.kind == crate::model::ProviderKind::McpStdio && !config.profile_headers.is_empty() {
return Err(
"PROVIDER_PROFILE_MAPPING_INVALID: stdio providers cannot map profile headers"
.to_string(),
);
}
if matches!(
config.kind,
crate::model::ProviderKind::McpHttp | crate::model::ProviderKind::OpenApi
) && !config.profile_env.is_empty()
{
return Err(
"PROVIDER_PROFILE_MAPPING_INVALID: HTTP providers cannot map profile environment values"
.to_string(),
);
}
for source in config
.profile_env
.values()
.chain(config.profile_headers.values())
{
validate_environment_name(source)?;
}
let controlled = store.controlled_profile_keys()?;
let ambient_sources = config
.secret_env
.iter()
.filter(|(destination, _)| {
config.profile_mode != ProfileMode::Required
|| !config.profile_env.contains_key(*destination)
})
.map(|(_, secret)| secret)
.chain(
config
.secret_headers
.iter()
.filter(|(destination, _)| {
config.profile_mode != ProfileMode::Required
|| !config.profile_headers.contains_key(*destination)
})
.map(|(_, secret)| secret),
);
if let Some(source) = ambient_sources
.filter(|secret| secret.provider == "env")
.map(|secret| &secret.reference)
.find(|source| controlled.binary_search(source).is_ok())
{
return Err(format!(
"PROVIDER_AMBIENT_PROFILE_REFERENCE: provider \"{}\" cannot read profile-controlled ambient variable \"{source}\"",
config.name
));
}
Ok(())
}
fn reject_provider_ambient_profile_key(store: &Store, name: &str) -> Result<(), String> {
for value in store.list_providers()? {
let config =
serde_json::from_value::<ConnectorConfig>(value).map_err(|error| error.to_string())?;
if config
.secret_env
.iter()
.filter(|(destination, _)| {
config.profile_mode != ProfileMode::Required
|| !config.profile_env.contains_key(*destination)
})
.map(|(_, secret)| secret)
.chain(
config
.secret_headers
.iter()
.filter(|(destination, _)| {
config.profile_mode != ProfileMode::Required
|| !config.profile_headers.contains_key(*destination)
})
.map(|(_, secret)| secret),
)
.any(|secret| secret.provider == "env" && secret.reference == name)
{
return Err(format!(
"PROFILE_KEY_PROVIDER_CONFLICT: profile variable \"{name}\" is still an ambient secret source for provider \"{}\"; replace it with a profile mapping first",
config.name
));
}
}
Ok(())
}
fn normalize_execution_workspace(
spec: &mut ExecutionSpec,
controller: &ProcessController,
) -> Result<(), String> {
if controller.hook_depth > 0 {
spec.labels.insert(
crate::hook::HOOK_DEPTH_LABEL.to_string(),
controller.hook_depth.to_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(())
}
struct RrExecutionSpecInput<'a> {
name: String,
purpose: &'a str,
idempotency_key: String,
argv: Vec<String>,
cwd: Option<String>,
env: BTreeMap<String, String>,
io: IoMode,
backend: ExecutionBackendSpec,
trace_id: &'a str,
}
struct DapExecutionSpecInput<'a> {
id: &'a str,
idempotency_key: String,
adapter_argv: Vec<String>,
cwd: Option<String>,
env: BTreeMap<String, String>,
}
struct DapAttachExecutionInput {
id: String,
adapter_argv: Vec<String>,
stable_target: String,
attach_arguments: Value,
started_stopped: bool,
cwd: Option<String>,
env: BTreeMap<String, String>,
timeout_ms: u64,
idempotency_key: String,
}
async fn execute_dap_attach(
debugger: DebuggerManager,
executions: ExecutionManager,
store: Arc<Store>,
controller: ProcessController,
input: DapAttachExecutionInput,
) -> Result<DebuggerRunResult, String> {
let mut spec = dap_execution_spec(DapExecutionSpecInput {
id: &input.id,
idempotency_key: format!("{}/adapter", input.idempotency_key),
adapter_argv: input.adapter_argv,
cwd: input.cwd,
env: input.env,
});
normalize_execution_workspace(&mut spec, &controller)?;
let cwd = spec.workspace.cwd.clone();
bind_profile(
&store,
cwd.as_deref(),
None,
parent_profile_binding(&store, controller.execution_id.as_deref(), &controller)?.as_ref(),
&mut spec,
)?;
let execution = executions
.start(spec, controller.clone(), None, Some(input.id.clone()))
.await?;
let timeout = Duration::from_millis(input.timeout_ms.clamp(1, 120_000));
let opened = async {
debugger
.dap_open(
input.id.clone(),
input.stable_target,
execution.id.clone(),
executions.clone(),
controller.clone(),
)
.await?;
let using_attach_commands = input
.attach_arguments
.get("attachCommands")
.and_then(Value::as_array)
.is_some_and(|commands| !commands.is_empty());
let mut attach_arguments = input.attach_arguments;
crate::debugger::dap::merge_init_commands(
&mut attach_arguments,
crate::debugger::dap::rust_init_commands(),
);
let attach = debugger
.dap_request(&input.id, "attach", attach_arguments, timeout)
.await;
let needs_pause = attach.as_ref().err().is_some_and(|error| {
using_attach_commands && error.to_ascii_lowercase().contains("failed to stop")
});
if let Err(error) = attach
&& !needs_pause
{
return Err(error);
}
let configured = debugger
.dap_request(
&input.id,
"configurationDone",
serde_json::json!({}),
timeout,
)
.await;
if let Err(error) = configured
&& !needs_pause
{
return Err(error);
}
if !input.started_stopped {
debugger.dap_pause(&input.id, timeout).await?;
}
debugger.dap_wait_for_pause(&input.id, 0, timeout).await?;
debugger.status(&input.id).await
}
.await;
match opened {
Ok(session) => Ok(DebuggerRunResult { execution, session }),
Err(error) => {
let _ = debugger.dap_mark_error(&input.id, error.clone()).await;
debugger.dap_abort(&input.id).await;
let _ = executions
.cancel_unclaimed(&execution.id, Duration::from_secs(5), &controller)
.await;
Err(error)
}
}
}
fn dap_execution_spec(input: DapExecutionSpecInput<'_>) -> ExecutionSpec {
let mut labels = BTreeMap::new();
labels.insert("apoc.debugger_session".to_string(), input.id.to_string());
labels.insert("apoc.debugger_adapter".to_string(), "dap".to_string());
ExecutionSpec {
schema_version: SCHEMA_VERSION,
idempotency_key: Some(input.idempotency_key),
name: format!("debugger/dap/{}", input.id),
purpose: Some("Run a DAP adapter under apoc execution ownership".to_string()),
labels,
program: ExecutionProgram::Command {
argv: input.adapter_argv,
shell: false,
},
backend: ExecutionBackendSpec::Native,
workspace: WorkspaceContext {
cwd: input.cwd,
..WorkspaceContext::default()
},
env: input.env,
secrets: BTreeMap::new(),
profile_selection: None,
io: IoMode::Pipes,
owner_kind: LeaseOwnerKind::Persistent,
owner_id: None,
expires_at: None,
retry: RetryPolicy::default(),
budget: ExecutionBudget::default(),
telemetry: TelemetryPolicy::default(),
expect: None,
}
}
fn rr_execution_spec(input: RrExecutionSpecInput<'_>) -> ExecutionSpec {
let mut labels = BTreeMap::new();
labels.insert("apoc.rr_trace".to_string(), input.trace_id.to_string());
ExecutionSpec {
schema_version: SCHEMA_VERSION,
idempotency_key: Some(input.idempotency_key),
name: input.name,
purpose: Some(input.purpose.to_string()),
labels,
program: ExecutionProgram::Command {
argv: input.argv,
shell: false,
},
backend: input.backend,
workspace: WorkspaceContext {
cwd: input.cwd,
..WorkspaceContext::default()
},
env: input.env,
secrets: BTreeMap::new(),
profile_selection: None,
io: input.io,
owner_kind: LeaseOwnerKind::Persistent,
owner_id: None,
expires_at: None,
retry: RetryPolicy::default(),
budget: ExecutionBudget::default(),
telemetry: TelemetryPolicy::default(),
expect: None,
}
}
fn spawn_rr_finalizer(
debugger: DebuggerManager,
executions: ExecutionManager,
trace_id: String,
execution_id: String,
) {
tokio::spawn(async move {
let terminal = executions.wait(&execution_id, None).await;
let (succeeded, error) = match terminal {
Ok(execution) => {
let succeeded = execution.status == ExecutionStatus::Completed;
if succeeded
&& matches!(
execution.spec.backend,
ExecutionBackendSpec::Isolated { .. }
)
{
let exported = execution
.result
.as_ref()
.and_then(|result| result.get("artifacts"))
.and_then(Value::as_array)
.and_then(|artifacts| {
artifacts.iter().find(|artifact| {
artifact.get("name").and_then(Value::as_str) == Some("rr-trace")
})
})
.cloned()
.ok_or_else(|| {
"Isolated rr execution completed without the rr-trace artifact"
.to_string()
})
.and_then(|artifact| {
serde_json::from_value::<ExecutionArtifactRef>(artifact)
.map_err(|error| error.to_string())
});
match exported {
Ok(exported) => {
if let Err(error) =
cleanup_isolated_rr_workspace(&execution, &trace_id, &exported)
{
return finish_rr_failed(&debugger, &trace_id, error);
}
match debugger
.rr_finish_isolated_record(&trace_id, &execution_id, &exported)
.await
{
Ok(_) => return,
Err(error) => return finish_rr_failed(&debugger, &trace_id, error),
}
}
Err(error) => return finish_rr_failed(&debugger, &trace_id, error),
}
}
let error = (!succeeded).then(|| {
executions
.logs(&execution_id, 32 * 1024)
.ok()
.and_then(|logs| {
let detail = if logs.stderr.trim().is_empty() {
logs.stdout
} else {
logs.stderr
};
(!detail.trim().is_empty()).then_some(detail)
})
.or_else(|| execution.result.map(|result| result.to_string()))
.unwrap_or_else(|| format!("rr execution ended as {:?}", execution.status))
});
(succeeded, error)
}
Err(error) => (false, Some(error)),
};
let _ = debugger.rr_finish_record(&trace_id, succeeded, error);
});
}
fn finish_rr_failed(debugger: &DebuggerManager, trace_id: &str, error: String) {
let _ = debugger.rr_finish_record(trace_id, false, Some(error));
}
fn isolated_rr_backend(
image: String,
guest_cwd: Option<String>,
exports: Vec<ExecutionExportSpec>,
) -> ExecutionBackendSpec {
ExecutionBackendSpec::Isolated {
isolation: IsolatedExecutionSpec {
image,
workspace: IsolatedWorkspaceMode::ReadWrite,
guest_cwd,
memory_mb: None,
cpu_count: None,
pids_max: None,
network: IsolatedNetworkPolicy::None,
exports,
},
}
}
fn isolated_rr_executable(executable: String) -> String {
if executable == "rr" {
"/usr/local/bin/rr".to_string()
} else {
executable
}
}
fn cleanup_isolated_rr_workspace(
execution: &crate::model::Execution,
trace_id: &str,
exported: &ExecutionArtifactRef,
) -> Result<(), String> {
let expected_source = format!("/workspace/.apoc-rr-{trace_id}");
if exported.source != expected_source {
return Err(format!(
"Isolated rr trace export source mismatch: expected {expected_source}, received {}",
exported.source
));
}
let workspace = execution
.spec
.workspace
.cwd
.as_deref()
.ok_or_else(|| "Isolated rr execution has no host workspace".to_string())?;
let temporary = Path::new(workspace).join(format!(".apoc-rr-{trace_id}"));
if temporary.is_dir() {
std::fs::remove_dir_all(&temporary).map_err(|error| {
format!(
"Could not remove isolated rr temporary trace {}: {error}",
temporary.display()
)
})?;
}
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 socket_identity(path: &Path) -> Option<(u64, u64)> {
use std::os::unix::fs::MetadataExt;
std::fs::metadata(path)
.ok()
.map(|metadata| (metadata.dev(), metadata.ino()))
}
fn remove_owned_socket(path: &Path, bound: Option<(u64, u64)>) {
if bound.is_some() && socket_identity(path) == bound {
let _ = std::fs::remove_file(path);
}
}
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(Clone, Default)]
pub(crate) struct DispatchSlot(Arc<std::sync::RwLock<Option<InProcess>>>);
tokio::task_local! {
static DISPATCH: DispatchSlot;
}
#[derive(Clone)]
pub(crate) struct InProcess {
daemon: std::sync::Weak<Daemon>,
runtime: tokio::runtime::Handle,
}
pub(crate) struct Serving(DispatchSlot);
impl Drop for Serving {
fn drop(&mut self) {
if let Ok(mut slot) = (self.0).0.write() {
*slot = None;
}
}
}
impl DispatchSlot {
fn serve(&self, daemon: &Arc<Daemon>) -> Serving {
if let Ok(mut slot) = self.0.write() {
*slot = Some(InProcess {
daemon: Arc::downgrade(daemon),
runtime: tokio::runtime::Handle::current(),
});
}
Serving(self.clone())
}
fn current(&self) -> Option<(Arc<Daemon>, tokio::runtime::Handle)> {
let serving = self.0.read().ok()?.clone()?;
Some((serving.daemon.upgrade()?, serving.runtime))
}
pub(crate) async fn scope<T>(&self, future: impl std::future::Future<Output = T>) -> T {
DISPATCH.scope(self.clone(), future).await
}
}
impl InProcess {
pub(crate) async fn call(
daemon: Arc<Daemon>,
runtime: tokio::runtime::Handle,
method: String,
params: Value,
controller: ProcessController,
) -> Result<Value, String> {
let home = daemon
.store
.path()
.parent()
.unwrap_or(std::path::Path::new("."))
.to_path_buf();
let diagnostic_controller = controller.clone();
let diagnostic_method = method.clone();
let result = async {
let read_timeout = daemon_rpc_read_timeout(&method, ¶ms);
let task = runtime.spawn({
let method = method.clone();
async move { daemon.dispatch(&method, params, &controller).await }
});
let response = match read_timeout {
Some(timeout) => tokio::time::timeout(timeout, task).await.map_err(|_| {
format!(
"DAEMON_RPC_TIMEOUT: phase=response_header method={method} timeout_ms={}",
timeout.as_millis()
)
})?,
None => task.await,
};
match response {
Ok(Ok(value)) => Ok(value),
Ok(Err(message)) => Err(format!("DAEMON_REQUEST_FAILED: {message}")),
Err(error) => Err(error.to_string()),
}
}
.await;
if let Err(error) = &result {
crate::error_telemetry::record_rpc_at(
&home,
&diagnostic_method,
Some(&diagnostic_controller.invocation_id),
diagnostic_controller.execution_id.as_deref(),
error,
);
}
result
}
}
#[derive(Debug, Clone, Default)]
pub struct DaemonClient;
impl DaemonClient {
pub async fn execute<O: DaemonOperation>(&self, operation: O) -> Result<O::Response, String> {
self.call(O::METHOD, operation).await
}
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 embedded = DISPATCH
.try_with(DispatchSlot::current)
.ok()
.flatten()
.is_some();
let result = self.call_value_inner(method, params, auto_start).await;
if !embedded
&& let Err(error) = &result
&& (auto_start || !error.starts_with("apoc daemon is not running:"))
{
let controller = controller(false);
let code = error
.split_once(':')
.map(|(code, _)| code)
.filter(|code| {
code.bytes()
.all(|byte| byte.is_ascii_uppercase() || byte == b'_')
})
.unwrap_or("DAEMON_TRANSPORT_ERROR");
crate::error_telemetry::record(
"rpc",
method,
code,
Some(&controller.invocation_id),
controller.execution_id.as_deref(),
error,
);
}
result
}
async fn call_value_inner(
&self,
method: &str,
params: Value,
auto_start: bool,
) -> Result<Value, String> {
let method = method.to_string();
let controller = controller(false);
if let Some((daemon, runtime)) = DISPATCH.try_with(DispatchSlot::current).ok().flatten() {
return InProcess::call(daemon, runtime, method, params, controller).await;
}
let read_timeout = daemon_rpc_read_timeout(&method, ¶ms);
match tokio::task::spawn_blocking({
let method = method.clone();
let params = params.clone();
let controller = controller.clone();
move || call_sync(&method, params, controller, read_timeout)
})
.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, read_timeout)
})
.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"))?;
let mut spawned = None;
let state = state_dir()?;
std::fs::create_dir_all(&state).map_err(|error| error.to_string())?;
let owner = if startup.is_some() {
try_acquire_lock(&state.join("owner.lock"))?
} else {
None
};
let should_spawn = startup.is_some() && owner.is_some();
drop(owner);
if should_spawn {
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 serve_idempotency_key = format!("daemon-serve:{}", uuid::Uuid::now_v7());
let descriptors = inherited_descriptors()?;
let mut command = tokio::process::Command::new(executable);
command
.args([
"daemon",
"serve",
"--purpose",
"Serving the durable apoc daemon.",
])
.args(["--idempotency-key", &serve_idempotency_key])
.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(())
});
}
spawned = Some(command.spawn().map_err(|error| error.to_string())?);
}
let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
let started = tokio::time::Instant::now();
loop {
if UnixStream::connect(socket_path()).await.is_ok() {
return Ok(());
}
if let Some(child) = &mut spawned
&& let Some(status) = child.try_wait().map_err(|error| error.to_string())?
{
return Err(format!(
"DAEMON_START_CHILD_EXITED: phase=daemon_process elapsed_ms={} status={status}; inspect {}",
started.elapsed().as_millis(),
log_path.display()
));
}
if tokio::time::Instant::now() >= deadline {
return Err(format!(
"DAEMON_START_TIMEOUT: phase={} elapsed_ms={} inspect {}",
if spawned.is_some() {
"socket_readiness"
} else {
"startup_contender"
},
started.elapsed().as_millis(),
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())
}
pub(crate) const MAX_FRAME_BYTES: usize = 16 * 1024 * 1024;
fn codec() -> LengthDelimitedCodec {
LengthDelimitedCodec::builder()
.max_frame_length(MAX_FRAME_BYTES)
.new_codec()
}
fn call_sync(
method: &str,
params: Value,
controller: ProcessController,
read_timeout: Option<Duration>,
) -> Result<Value, DaemonCallError> {
call_sync_at_with_timeout(&socket_path(), method, params, controller, read_timeout)
}
#[cfg(test)]
fn call_sync_at(
socket: &Path,
method: &str,
params: Value,
controller: ProcessController,
) -> Result<Value, DaemonCallError> {
call_sync_at_with_timeout(
socket,
method,
params,
controller,
Duration::from_secs(10 * 60),
)
}
fn call_sync_at_with_timeout(
socket: &Path,
method: &str,
params: Value,
controller: ProcessController,
read_timeout: impl Into<Option<Duration>>,
) -> Result<Value, DaemonCallError> {
let read_timeout = read_timeout.into();
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(),
));
}
let mut stream = std::os::unix::net::UnixStream::connect(socket)
.map_err(|error| DaemonCallError::Unavailable(error.to_string()))?;
stream
.set_read_timeout(read_timeout)
.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()))?;
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| {
daemon_rpc_read_error(method, "response_header", read_timeout, None, error)
})?;
let length = u32::from_be_bytes(length) as usize;
if length > MAX_FRAME_BYTES {
return Err(DaemonCallError::RequestFailed(format!(
"DAEMON_RPC_OVERSIZED: phase=response_header method={method} \
expected_bytes={length} limit_bytes={MAX_FRAME_BYTES}"
)));
}
let mut payload = vec![0_u8; length];
stream.read_exact(&mut payload).map_err(|error| {
daemon_rpc_read_error(method, "response_body", read_timeout, Some(length), error)
})?;
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 daemon_rpc_read_timeout(method: &str, params: &Value) -> Option<Duration> {
match method {
"daemon.status" | "daemon.ping" | "daemon.stop" => Some(Duration::from_secs(2)),
"code.run" | "code.wait" | "execution.wait" => params
.get("timeout_ms")
.and_then(Value::as_u64)
.map(|milliseconds| Duration::from_millis(milliseconds.saturating_add(30_000))),
"execution.command" | "execution.batch" | "execution.pipeline" | "poll.run" => None,
_ => Some(Duration::from_secs(10 * 60)),
}
}
fn daemon_rpc_read_error(
method: &str,
phase: &str,
timeout: Option<Duration>,
expected_bytes: Option<usize>,
error: std::io::Error,
) -> DaemonCallError {
if matches!(
error.kind(),
std::io::ErrorKind::TimedOut | std::io::ErrorKind::WouldBlock
) {
DaemonCallError::RequestFailed(format!(
"DAEMON_RPC_TIMEOUT: phase={phase} method={method} timeout_ms={}",
timeout
.map(|value| value.as_millis().to_string())
.unwrap_or_else(|| "unbounded".to_string())
))
} else if error.kind() == std::io::ErrorKind::UnexpectedEof {
let expected =
expected_bytes.map_or_else(|| "unknown".to_string(), |bytes| bytes.to_string());
DaemonCallError::RequestFailed(format!(
"DAEMON_RPC_TRUNCATED: phase={phase} method={method} expected_bytes={expected} \
(the daemon closed the connection without answering; a response over \
{MAX_FRAME_BYTES} bytes cannot be encoded)"
))
} else {
DaemonCallError::RequestFailed(error.to_string())
}
}
fn resolve_recipe_path(controller: &ProcessController, file: &str) -> Result<PathBuf, String> {
resolve_controller_path(controller, file, "recipe file")
}
fn resolve_controller_path(
controller: &ProcessController,
file: &str,
kind: &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(|| format!("A relative {kind} requires an invoking current directory"))
}
fn validate_hook_definition(params: &HookPutParams) -> Result<(), String> {
let name = params.name.trim();
if name.is_empty() || name.contains("::") {
return Err(
"HOOK_NAME_INVALID: Hook names must be non-empty and cannot contain ::".to_string(),
);
}
let command = params.command.trim();
if command.is_empty() || command.contains(char::is_whitespace) || command.starts_with("hook.") {
return Err(
"HOOK_COMMAND_INVALID: Use one exact non-hook canonical command path".to_string(),
);
}
let programs = [
params.on_start.as_deref(),
params.on_success.as_deref(),
params.on_failure.as_deref(),
];
if !programs
.into_iter()
.flatten()
.any(|program| !program.trim().is_empty())
{
return Err(
"HOOK_PROGRAM_REQUIRED: Set at least one of on_start, on_success, or on_failure"
.to_string(),
);
}
if params.max_attempts == 0 {
return Err("HOOK_ATTEMPTS_INVALID: max_attempts must be at least 1".to_string());
}
if params.timeout_ms == 0 {
return Err("HOOK_TIMEOUT_INVALID: timeout_ms must be at least 1".to_string());
}
Ok(())
}
fn visible_hook(
store: &Store,
scope_kind: RecipeScopeKind,
scope_key: Option<&str>,
name: &str,
) -> Result<Option<Hook>, String> {
if scope_kind != RecipeScopeKind::Global
&& let Some(hook) = store.get_hook(scope_kind, scope_key, name)?
{
return Ok(Some(hook));
}
store.get_hook(RecipeScopeKind::Global, None, name)
}
fn visible_hooks(
store: &Store,
scope_kind: RecipeScopeKind,
scope_key: Option<&str>,
) -> Result<Vec<Hook>, String> {
let hooks = store.list_hooks()?;
let mut visible = BTreeMap::<String, Hook>::new();
for hook in hooks
.iter()
.filter(|hook| hook.scope_kind == RecipeScopeKind::Global)
{
visible.insert(hook.name.clone(), hook.clone());
}
if scope_kind != RecipeScopeKind::Global {
for hook in hooks
.iter()
.filter(|hook| hook.scope_kind == scope_kind && hook.scope_key.as_deref() == scope_key)
{
visible.insert(hook.name.clone(), hook.clone());
}
}
Ok(visible.into_values().collect())
}
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,
}
#[derive(Serialize, Deserialize)]
struct ProviderMutationReplay {
operation: String,
fingerprint: String,
result: Option<ProviderMutationResult>,
}
#[derive(Serialize, Deserialize)]
enum ProviderMutationResult {
Ok(Value),
Err(String),
}
impl ProviderMutationResult {
fn from_result(result: &Result<Value, String>) -> Self {
match result {
Ok(value) => Self::Ok(value.clone()),
Err(error) => Self::Err(error.clone()),
}
}
fn into_result(self) -> Result<Value, String> {
match self {
Self::Ok(value) => Ok(value),
Self::Err(error) => Err(error),
}
}
}
fn provider_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 provider_mutation_replay(
store: &Store,
key: &str,
operation: &str,
fingerprint: &str,
) -> Result<Option<Result<Value, String>>, String> {
let intent = ProviderMutationReplay {
operation: operation.to_string(),
fingerprint: fingerprint.to_string(),
result: None,
};
let Some(replay) =
store.claim_receipt(&format!("provider:{key}"), "provider_replay", &intent)?
else {
return Ok(None);
};
if replay.operation != operation || replay.fingerprint != fingerprint {
return Err(format!(
"PROVIDER_IDEMPOTENCY_CONFLICT: key \"{key}\" was already used for a different request"
));
}
let result = replay.result.ok_or_else(|| {
format!(
"PROVIDER_IDEMPOTENCY_INCOMPLETE: key \"{key}\" has durable intent without a terminal result"
)
})?;
Ok(Some(result.into_result()))
}
fn provider_mutation_record(
store: &Store,
key: &str,
operation: &str,
fingerprint: &str,
result: &Result<Value, String>,
) -> Result<(), String> {
store.put_receipt(
&format!("provider:{key}"),
"provider_replay",
&ProviderMutationReplay {
operation: operation.to_string(),
fingerprint: fingerprint.to_string(),
result: Some(ProviderMutationResult::from_result(result)),
},
)
}
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())
}
const CODE_SNAPSHOT_ENTRIES: usize = 200;
fn bounded_code_state(state: &CodeExecutionState) -> Result<Value, String> {
let mut value = json(state)?;
let Some(object) = value.as_object_mut() else {
return Ok(value);
};
let mut dropped = serde_json::Map::new();
for field in ["log", "logs", "events"] {
let Some(entries) = object.get_mut(field).and_then(Value::as_array_mut) else {
continue;
};
let total = entries.len();
if total <= CODE_SNAPSHOT_ENTRIES {
continue;
}
entries.drain(..total - CODE_SNAPSHOT_ENTRIES);
dropped.insert(field.to_owned(), Value::from(total - CODE_SNAPSHOT_ENTRIES));
}
if !dropped.is_empty() {
object.insert("truncated".to_owned(), Value::Object(dropped));
object.insert(
"truncated_note".to_owned(),
Value::from(format!(
"Older entries were dropped so the snapshot fits the daemon frame; the newest {CODE_SNAPSHOT_ENTRIES} of each are kept."
)),
);
}
Ok(value)
}
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 log_slice_request(params: &LogsParams) -> Result<Option<crate::run::LogSliceRequest>, String> {
if params.grep.is_none() && params.lines.is_none() {
return Ok(None);
}
if params.grep.is_some() && params.lines.is_some() {
return Err("Use --grep or --lines, not both".to_string());
}
let pattern = params
.grep
.as_deref()
.map(|pattern| {
regex::Regex::new(pattern).map_err(|error| format!("Invalid --grep pattern: {error}"))
})
.transpose()?;
let (start, end) = match params.lines.as_deref() {
Some(range) => parse_line_range(range)?,
None => (0, 0),
};
Ok(Some(crate::run::LogSliceRequest {
pattern,
context: params.context.unwrap_or(2),
max_matches: params.max_matches.unwrap_or(20).max(1),
start,
end,
}))
}
fn parse_line_range(value: &str) -> Result<(usize, usize), String> {
let value = value.trim();
let (start, end) = match value.split_once('-') {
Some((start, end)) => (start.trim(), end.trim()),
None => (value, value),
};
let start = start
.parse::<usize>()
.map_err(|_| format!("Invalid line range \"{value}\". Use START-END."))?;
let end = end
.parse::<usize>()
.map_err(|_| format!("Invalid line range \"{value}\". Use START-END."))?;
if start == 0 || end < start {
return Err(format!(
"Invalid line range \"{value}\". Lines are one-based and START must not exceed END."
));
}
Ok((start, end))
}
fn code_execution_error_code(error: &str) -> &'static str {
if error.starts_with("CODE_EXECUTION_TIMEOUT:") {
"CODE_EXECUTION_TIMEOUT"
} else {
"CODE_EXECUTION_FAILED"
}
}
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 serde::Serializer;
use tempfile::tempdir;
use super::*;
#[test]
fn synchronous_execution_rpcs_leave_deadlines_to_the_execution_engine() {
for method in [
"execution.command",
"execution.batch",
"execution.pipeline",
"poll.run",
] {
assert_eq!(
daemon_rpc_read_timeout(method, &serde_json::json!({})),
None
);
}
assert_eq!(
daemon_rpc_read_timeout("code.run", &serde_json::json!({})),
None
);
for method in ["code.run", "execution.wait"] {
let request = serde_json::json!({"timeout_ms": 1800000});
assert!(
daemon_rpc_read_timeout(method, &request).unwrap() > Duration::from_secs(30 * 60)
);
}
assert_eq!(
daemon_rpc_read_timeout("daemon.status", &serde_json::json!({"timeout_ms": 1800000})),
Some(Duration::from_secs(2))
);
assert_eq!(
daemon_rpc_read_timeout("execution.get", &serde_json::json!({})),
Some(Duration::from_secs(10 * 60))
);
}
#[test]
fn rpc_deadline_does_not_cut_a_declared_long_wait_short() {
let request = serde_json::json!({"timeout_ms": 1800000});
let requested = Duration::from_millis(request["timeout_ms"].as_u64().unwrap());
let deadline = daemon_rpc_read_timeout("code.run", &request).unwrap();
assert!(
deadline > requested,
"RPC deadline cuts the declared 30-minute wait short: {deadline:?}",
);
}
#[test]
fn a_long_run_snapshot_keeps_its_result_and_drops_only_old_entries() {
use incurs_codemode::ExecutionStatus as Code;
let mut state = CodeExecutionState {
id: "exec-long".to_owned(),
code: "return 1".to_owned(),
status: Code::Completed,
log: Vec::new(),
result: Some(serde_json::json!({ "apm": 1667 })),
error: None,
logs: (0..1000).map(|i| format!("line {i}")).collect(),
connectors: Vec::new(),
capabilities: None,
events: Vec::new(),
created_at: 1,
updated_at: 2,
};
state.logs.push("last line".to_owned());
let value = bounded_code_state(&state).unwrap();
let object = value.as_object().unwrap();
assert_eq!(object["result"], serde_json::json!({ "apm": 1667 }));
assert_eq!(object["status"], serde_json::json!("completed"));
let logs = object["logs"].as_array().unwrap();
assert_eq!(logs.len(), CODE_SNAPSHOT_ENTRIES, "logs should be bounded");
assert_eq!(
logs.last().unwrap(),
"last line",
"the newest entries are the ones kept"
);
assert_eq!(
object["truncated"]["logs"],
serde_json::json!(1001 - CODE_SNAPSHOT_ENTRIES),
"the snapshot should say how much it dropped"
);
}
#[test]
fn a_short_run_snapshot_is_left_exactly_as_it_was() {
use incurs_codemode::ExecutionStatus as Code;
let state = CodeExecutionState {
id: "exec-short".to_owned(),
code: "return 1".to_owned(),
status: Code::Completed,
log: Vec::new(),
result: Some(serde_json::json!("done")),
error: None,
logs: vec!["only line".to_owned()],
connectors: Vec::new(),
capabilities: None,
events: Vec::new(),
created_at: 1,
updated_at: 2,
};
let value = bounded_code_state(&state).unwrap();
let object = value.as_object().unwrap();
assert_eq!(object["logs"].as_array().unwrap().len(), 1);
assert!(
!object.contains_key("truncated"),
"nothing was dropped, so nothing should claim it was"
);
}
#[test]
fn shutdown_removes_its_own_socket_but_never_a_successor_socket() {
let directory = tempdir().unwrap();
let path = directory.path().join("apoc.sock");
let departing = StdUnixListener::bind(&path).unwrap();
let bound = socket_identity(&path).unwrap();
std::fs::remove_file(&path).unwrap();
let successor_listener = StdUnixListener::bind(&path).unwrap();
let successor = socket_identity(&path).unwrap();
assert_ne!(bound, successor);
remove_owned_socket(&path, Some(bound));
assert!(
path.exists(),
"a departing daemon removed a socket it never bound"
);
remove_owned_socket(&path, Some(successor));
assert!(!path.exists(), "a daemon left its own socket behind");
drop((departing, successor_listener));
}
#[test]
fn preserves_code_execution_timeout_error_code() {
assert_eq!(
code_execution_error_code("CODE_EXECUTION_TIMEOUT: 300000ms active budget exhausted"),
"CODE_EXECUTION_TIMEOUT"
);
assert_eq!(
code_execution_error_code("Exception generated by QuickJS"),
"CODE_EXECUTION_FAILED"
);
}
#[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(_))));
}
#[test]
fn validates_paths_scopes_reservations_logs_and_statuses() {
let directory = tempdir().unwrap();
let absolute = directory.path().join("bundle.json");
let mut controller = ProcessController::capture(true, None);
controller.cwd = Some(directory.path().to_string_lossy().into_owned());
assert_eq!(
resolve_recipe_path(&controller, absolute.to_str().unwrap()).unwrap(),
absolute
);
assert_eq!(
resolve_recipe_path(&controller, "bundle.json").unwrap(),
directory.path().join("bundle.json")
);
controller.cwd = None;
assert!(resolve_recipe_path(&controller, "bundle.json").is_err());
assert_eq!(
selected_recipe_scope(&controller, true, None).unwrap(),
(RecipeScopeKind::Global, None)
);
assert!(selected_recipe_scope(&controller, true, Some("/tmp")).is_err());
assert!(selected_recipe_scope(&controller, false, None).is_err());
controller.cwd = Some(directory.path().to_string_lossy().into_owned());
let (_, relative_key) = selected_recipe_scope(&controller, false, Some("nested")).unwrap();
assert!(relative_key.unwrap().ends_with("/nested"));
let (_, absolute_key) =
selected_recipe_scope(&controller, false, Some(directory.path().to_str().unwrap()))
.unwrap();
let canonical_directory = directory.path().canonicalize().unwrap();
assert_eq!(absolute_key.as_deref(), canonical_directory.to_str());
for (name, expected) in [
("port", ReservationKind::Port),
("path", ReservationKind::Path),
("process", ReservationKind::Process),
("device", ReservationKind::Device),
("custom", ReservationKind::Custom),
] {
assert_eq!(reservation_kind(name).unwrap(), expected);
}
assert!(reservation_kind("unknown").is_err());
assert!(reservation_key(ReservationKind::Custom, "").is_err());
assert_eq!(
reservation_key(ReservationKind::Port, "5173").unwrap(),
"tcp/5173"
);
assert_eq!(
reservation_key(ReservationKind::Port, "udp/53").unwrap(),
"udp/53"
);
assert_eq!(
reservation_key(ReservationKind::Port, "53/UDP").unwrap(),
"udp/53"
);
assert!(reservation_key(ReservationKind::Port, "sctp/53").is_err());
assert!(reservation_key(ReservationKind::Port, "tcp/not-a-port").is_err());
assert_eq!(
reservation_key(ReservationKind::Path, absolute.to_str().unwrap()).unwrap(),
absolute.to_string_lossy()
);
assert!(
reservation_key(ReservationKind::Path, "relative")
.unwrap()
.ends_with("/relative")
);
assert!(reservation_key(ReservationKind::Process, "pid-only").is_err());
assert_eq!(
reservation_key(ReservationKind::Process, "boot:7@9").unwrap(),
"boot:7@9"
);
assert_eq!(
reservation_key(ReservationKind::Device, "phone").unwrap(),
"phone"
);
assert_eq!(parse_reservation_port("tcp/5173").unwrap(), ("tcp", 5173));
assert!(parse_reservation_port("5173").is_err());
assert!(parse_reservation_port("tcp/nope").is_err());
assert_eq!(session_lease_id("session"), "session/session");
let tail = LogsParams {
id: "execution".to_string(),
tail_bytes: 64,
grep: None,
context: None,
max_matches: None,
lines: None,
};
assert!(log_slice_request(&tail).unwrap().is_none());
let mut both = tail;
both.grep = Some("match".to_string());
both.lines = Some("1-2".to_string());
assert!(log_slice_request(&both).is_err());
both.lines = None;
both.context = Some(4);
both.max_matches = Some(0);
let request = log_slice_request(&both).unwrap().unwrap();
assert_eq!(request.context, 4);
assert_eq!(request.max_matches, 1);
assert!(request.pattern.unwrap().is_match("a match"));
both.grep = Some("[".to_string());
assert!(log_slice_request(&both).is_err());
both.grep = None;
both.lines = Some("7".to_string());
let request = log_slice_request(&both).unwrap().unwrap();
assert_eq!((request.start, request.end), (7, 7));
assert_eq!(parse_line_range(" 2 - 5 ").unwrap(), (2, 5));
for invalid in ["", "a", "1-b", "0", "3-2"] {
assert!(parse_line_range(invalid).is_err(), "{invalid}");
}
assert_eq!(
code_status(CodeExecutionStatus::Running),
ExecutionStatus::Running
);
assert_eq!(
code_status(CodeExecutionStatus::Paused),
ExecutionStatus::Interrupted
);
assert_eq!(
code_status(CodeExecutionStatus::Completed),
ExecutionStatus::Completed
);
assert_eq!(
code_status(CodeExecutionStatus::Cancelled),
ExecutionStatus::Canceled
);
for status in [
CodeExecutionStatus::Error,
CodeExecutionStatus::Rejected,
CodeExecutionStatus::RolledBack,
] {
assert_eq!(code_status(status), ExecutionStatus::Failed);
assert!(code_terminal(status));
}
assert!(!code_terminal(CodeExecutionStatus::Running));
assert!(!code_terminal(CodeExecutionStatus::Paused));
assert!(code_terminal(CodeExecutionStatus::Completed));
assert!(code_terminal(CodeExecutionStatus::Cancelled));
for (status, name) in [
(ExecutionStatus::Queued, "queued"),
(ExecutionStatus::Running, "running"),
(ExecutionStatus::Stalled, "stalled"),
(ExecutionStatus::Interrupted, "interrupted"),
(ExecutionStatus::Completed, "completed"),
(ExecutionStatus::Failed, "failed"),
(ExecutionStatus::Canceled, "canceled"),
] {
assert_eq!(model_status_name(status), name);
}
}
#[test]
fn validates_recipe_helpers_and_replay_contracts() {
let directory = tempdir().unwrap();
let store = Store::open(directory.path().join("state.sqlite3")).unwrap();
let output = serde_json::json!({"ok": true});
let fingerprint = recipe_request_fingerprint("recipe.put", &output).unwrap();
assert_eq!(
fingerprint,
recipe_request_fingerprint("recipe.put", &output).unwrap()
);
assert!(
recipe_replay(&store, None, "recipe.put", &fingerprint)
.unwrap()
.is_none()
);
assert!(
recipe_replay(&store, Some("missing"), "recipe.put", &fingerprint)
.unwrap()
.is_none()
);
recipe_record_replay(&store, None, "recipe.put", &fingerprint, &output).unwrap();
recipe_record_replay(&store, Some("replay"), "recipe.put", &fingerprint, &output).unwrap();
assert_eq!(
recipe_replay(&store, Some("replay"), "recipe.put", &fingerprint).unwrap(),
Some(output.clone())
);
assert!(recipe_replay(&store, Some("replay"), "recipe.run", &fingerprint).is_err());
assert!(recipe_replay(&store, Some("replay"), "recipe.put", "other").is_err());
let schema = serde_json::json!({"type": "object", "required": ["name"]});
validate_recipe_schema(None, "SCHEMA").unwrap();
validate_recipe_schema(Some(&schema), "SCHEMA").unwrap();
assert!(validate_recipe_schema(Some(&serde_json::json!({"type": 7})), "SCHEMA").is_err());
validate_recipe_value(None, &Value::Null, "INPUT").unwrap();
validate_recipe_value(Some(&schema), &serde_json::json!({"name": "apoc"}), "INPUT")
.unwrap();
assert!(validate_recipe_value(Some(&schema), &serde_json::json!({}), "INPUT").is_err());
assert!(
validate_recipe_value(Some(&serde_json::json!({"type": 7})), &Value::Null, "INPUT")
.is_err()
);
let root = fixture_recipe("root", RecipeScopeKind::Global, None, vec!["dep"]);
let dep = fixture_recipe("dep", RecipeScopeKind::Global, None, Vec::new());
let graph = ResolvedRecipeGraph {
root: root.clone(),
recipes: BTreeMap::from([
(dep.name.clone(), dep.clone()),
(root.name.clone(), root.clone()),
]),
};
let code = composed_recipe_code(&graph, &serde_json::json!({"name": "apoc"})).unwrap();
assert!(code.contains("__apocRecipeFns[\"dep\"]"));
assert!(code.contains("__apocRecipeFns[\"root\"]"));
store.put_recipe_definition(&dep).unwrap();
store.put_recipe_definition(&root).unwrap();
let resolved = resolve_recipe_graph(&store, RecipeScopeKind::Global, None, "root").unwrap();
assert_eq!(resolved.root.name, "root");
assert_eq!(resolved.recipes.len(), 2);
assert!(resolve_visible_recipe(&store, RecipeScopeKind::Global, None, "missing").is_err());
let mut expired = fixture_recipe("expired", RecipeScopeKind::Global, None, Vec::new());
expired.expires_at = Some(1);
store.put_recipe_definition(&expired).unwrap();
assert!(resolve_visible_recipe(&store, RecipeScopeKind::Global, None, "expired").is_err());
let missing_dependency = fixture_recipe(
"missing-dependency",
RecipeScopeKind::Global,
None,
vec!["absent"],
);
store.put_recipe_definition(&missing_dependency).unwrap();
assert!(
resolve_recipe_graph(&store, RecipeScopeKind::Global, None, "missing-dependency")
.is_err()
);
let cycle_a = fixture_recipe("cycle-a", RecipeScopeKind::Global, None, vec!["cycle-b"]);
let cycle_b = fixture_recipe("cycle-b", RecipeScopeKind::Global, None, vec!["cycle-a"]);
store.put_recipe_definition(&cycle_a).unwrap();
store.put_recipe_definition(&cycle_b).unwrap();
assert!(resolve_recipe_graph(&store, RecipeScopeKind::Global, None, "cycle-a").is_err());
let mut recipes = BTreeMap::new();
let mut stack = Vec::new();
assert!(
resolve_recipe_dependencies(
&store,
RecipeScopeKind::Global,
None,
&root,
&mut recipes,
&mut stack,
16
)
.is_err()
);
recipes.insert(root.name.clone(), root.clone());
resolve_recipe_dependencies(
&store,
RecipeScopeKind::Global,
None,
&root,
&mut recipes,
&mut stack,
0,
)
.unwrap();
recipes.clear();
for index in 0..64 {
recipes.insert(
format!("fixture-{index}"),
fixture_recipe(
&format!("fixture-{index}"),
RecipeScopeKind::Global,
None,
Vec::new(),
),
);
}
assert!(
resolve_recipe_dependencies(
&store,
RecipeScopeKind::Global,
None,
&root,
&mut recipes,
&mut stack,
0
)
.is_err()
);
assert!(parse::<TimeoutParams>(Value::Null).is_err());
assert_eq!(json(serde_json::json!({"ok": true})).unwrap(), output);
assert!(json(RefusesSerialization).is_err());
}
#[test]
fn validates_every_rpc_response_boundary() {
let directory = tempdir().unwrap();
let socket = directory.path().join("success.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: Some(serde_json::json!({"ok": true})),
error: None,
},
);
});
assert_eq!(
call_sync_at(
&socket,
"daemon.test",
Value::Null,
ProcessController::capture(true, None)
)
.unwrap(),
serde_json::json!({"ok": true})
);
server.join().unwrap();
for (name, response) in [
(
"mismatched",
RpcResponse {
id: "different".to_string(),
result: Some(Value::Null),
error: None,
},
),
(
"invalid",
RpcResponse {
id: String::new(),
result: None,
error: None,
},
),
] {
let socket = directory.path().join(format!("{name}.sock"));
let listener = StdUnixListener::bind(&socket).unwrap();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let request = read_request(&mut stream);
let response = if name == "invalid" {
RpcResponse {
id: request.id,
..response
}
} else {
response
};
write_response(&mut stream, response);
});
assert!(matches!(
call_sync_at(
&socket,
"daemon.test",
Value::Null,
ProcessController::capture(true, None)
),
Err(DaemonCallError::RequestFailed(_))
));
server.join().unwrap();
}
let socket = directory.path().join("malformed.sock");
let listener = StdUnixListener::bind(&socket).unwrap();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let _ = read_request(&mut stream);
stream.write_all(&4_u32.to_be_bytes()).unwrap();
stream.write_all(b"nope").unwrap();
});
assert!(matches!(
call_sync_at(
&socket,
"daemon.test",
Value::Null,
ProcessController::capture(true, None)
),
Err(DaemonCallError::RequestFailed(_))
));
server.join().unwrap();
let socket = directory.path().join("oversized-response.sock");
let listener = StdUnixListener::bind(&socket).unwrap();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let _ = read_request(&mut stream);
stream
.write_all(&((16 * 1024 * 1024 + 1) as u32).to_be_bytes())
.unwrap();
});
let error = call_sync_at(
&socket,
"daemon.test",
Value::Null,
ProcessController::capture(true, None),
)
.unwrap_err();
assert!(
matches!(&error, DaemonCallError::RequestFailed(message)
if message.contains("DAEMON_RPC_OVERSIZED")
&& message.contains("method=daemon.test")
&& message.contains("limit_bytes=")),
"an oversized response must name the method and the limit: {error:?}"
);
server.join().unwrap();
let socket = directory.path().join("missing-oversized-request.sock");
let error = call_sync_at(
&socket,
"daemon.test",
Value::String("x".repeat(16 * 1024 * 1024 + 1)),
ProcessController::capture(true, None),
)
.unwrap_err();
assert!(
matches!(error, DaemonCallError::RequestFailed(message) if message.contains("request exceeds"))
);
}
#[test]
fn a_closed_connection_names_the_method_and_the_frame_limit() {
let directory = tempfile::tempdir().unwrap();
let socket = directory.path().join("closed.sock");
let listener = StdUnixListener::bind(&socket).unwrap();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let _ = read_request(&mut stream);
drop(stream);
});
let error = call_sync_at(
&socket,
"debugger.list",
Value::Null,
ProcessController::capture(true, None),
)
.unwrap_err();
server.join().unwrap();
let DaemonCallError::RequestFailed(message) = &error else {
panic!("expected a request failure, got {error:?}");
};
assert!(
message.contains("DAEMON_RPC_TRUNCATED"),
"must be attributable, got: {message}"
);
assert!(
message.contains("method=debugger.list"),
"must name the call, got: {message}"
);
assert!(
!message.contains("failed to fill whole buffer"),
"must not fall back to the bare io error, got: {message}"
);
}
fn fixture_recipe(
name: &str,
scope_kind: RecipeScopeKind,
scope_key: Option<&str>,
dependencies: Vec<&str>,
) -> Recipe {
Recipe {
name: name.to_string(),
description: format!("Fixture {name}"),
code: "return input;".to_string(),
input_schema: None,
output_schema: None,
dependencies: dependencies.into_iter().map(str::to_string).collect(),
required_env: Vec::new(),
annotations: RecipeAnnotations::default(),
scope_kind,
scope_key: scope_key.map(str::to_string),
generation: format!("generation-{name}"),
expires_at: None,
last_used_at: None,
created_at: 10,
updated_at: 10,
origin_suggestion_id: None,
origin_recording_id: None,
}
}
struct RefusesSerialization;
impl Serialize for RefusesSerialization {
fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Err(serde::ser::Error::custom("refused for coverage"))
}
}
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();
}
}