Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

chore: in memory agent trigger (#5799)

Wolf Mermelsteine2c69945cc22
diff --git a/.github/workflows/ensure_daytona_snapshot.yml b/.github/workflows/ensure_daytona_snapshot.yml
new file mode 100644
index 0000000000..b5bcffbbd1
--- /dev/null
+++ b/.github/workflows/ensure_daytona_snapshot.yml
@@ -0,0 +1,49 @@
+# DO NOT EDIT — regenerate with `cargo x workflows` (from the repository root).
+# Source: tooling/xtask/crates/xtask_workflows/src/workflows/ensure_daytona_snapshot.rs
+name: Ensure Daytona Snapshot
+'on':
+ push:
+ branches:
+ - main
+ paths:
+ - crates/agent_harness/container/**
+ - crates/agent_harness/justfile
+ - nix/cloud-storage.nix
+ - tooling/xtask/crates/xtask_workflows/src/workflows/ensure_daytona_snapshot.rs
+ - '.github/workflows/ensure_daytona_snapshot.yml'
+ workflow_dispatch: {}
+permissions:
+ contents: read
+jobs:
+ ensure-snapshot:
+ name: Ensure macro-agent-harness snapshot
+ runs-on: namespace-profile-linux-small
+ steps:
+ - name: Checkout
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
+ with:
+ clean: 'false'
+ persist-credentials: 'false'
+ - name: Mount /nix cache volume
+ uses: namespacelabs/nscloud-cache-action@15799a6b54e5765f85b2aac25b3f0df43ed571c0
+ with:
+ cache: nix
+ continue-on-error: true
+ - name: Setup Nix
+ uses: './.github/actions/setup-nix'
+ - name: Setup Nix dev shell
+ uses: './.github/actions/setup-nix-dev-shell'
+ - name: Ensure Daytona snapshot
+ run: |
+ set -euo pipefail
+ if [[ -z "${DAYTONA_API_KEY:-}" ]]; then
+ echo "::error::DAYTONA_API_KEY repository secret is not configured"
+ exit 1
+ fi
+ just --justfile crates/agent_harness/justfile ensure-daytona
+ shell: bash
+ env:
+ DAYTONA_API_KEY: ${{ secrets.DAYTONA_API_KEY }}
+concurrency:
+ group: ${{ github.workflow }}
+ cancel-in-progress: false
diff --git a/crates/agent_harness/justfile b/crates/agent_harness/justfile
index fec8898377..3fde87d9c1 100644
--- a/crates/agent_harness/justfile
+++ b/crates/agent_harness/justfile
@@ -22,8 +22,8 @@ default_prompt := "list the files in the repo root, then stop"
default:
@just --list
-# Build the Daytona snapshot if missing, then boot an agent in a sandbox
-boot-daytona prompt=default_prompt:
+# Build the Daytona snapshot if missing.
+ensure-daytona:
#!/usr/bin/env bash
set -euo pipefail
# Daytona has no "build from a local Dockerfile at create time" mode, so
@@ -46,6 +46,11 @@ boot-daytona prompt=default_prompt:
--context . \
--cpu 4 --memory 8 --disk 10 )
fi
+
+# Build the Daytona snapshot if missing, then boot an agent in a sandbox
+boot-daytona prompt=default_prompt: ensure-daytona
+ #!/usr/bin/env bash
+ set -euo pipefail
DAYTONA_SNAPSHOT={{image_name}} cargo run -p agent_harness --bin boot_agent -- daytona {{ quote(prompt) }}
# Delete the Daytona snapshot so the next boot rebuilds it
diff --git a/docker/Dockerfile.dev b/docker/Dockerfile.dev
index 8549892231..f18f1054bb 100644
--- a/docker/Dockerfile.dev
+++ b/docker/Dockerfile.dev
@@ -27,7 +27,7 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry,sharing=shared \
--bin static_file_service \
--bin unfurl_service \
--bin image_proxy_service \
- --bin agent_trigger_service \
+ --bin agent_harness_service \
&& mkdir -p /app/out \
&& cp /app/target/debug/authentication_service /app/out/ \
&& cp /app/target/debug/connection_gateway_service /app/out/ \
@@ -41,7 +41,7 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry,sharing=shared \
&& cp /app/target/debug/static_file_service /app/out/ \
&& cp /app/target/debug/unfurl_service /app/out/ \
&& cp /app/target/debug/image_proxy_service /app/out/ \
- && cp /app/target/debug/agent_trigger_service /app/out/
+ && cp /app/target/debug/agent_harness_service /app/out/
# Base runtime image
FROM debian:trixie-slim AS base
@@ -87,6 +87,3 @@ CMD ["/app/out/unfurl_service"]
FROM services_bundle AS image_proxy_service
CMD ["/app/out/image_proxy_service"]
-
-FROM services_bundle AS agent_trigger_service
-CMD ["/app/out/agent_trigger_service"]
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index a696bd4290..247f1c8f49 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -295,34 +295,18 @@ services:
retries: 3
start_period: 10s
- # ============================================================================
- # agent_trigger_service (portless local worker)
- # Channel messages -> agent session trigger events
- # ============================================================================
- agent_trigger_service:
- <<: [*common-env, *rust-services-image]
- command: ["/app/out/agent_trigger_service"]
- restart: on-failure
- depends_on:
- - postgres
- - kafka
- networks:
- - databases
- - services
-
# ============================================================================
# agent_harness_service (Port 8101)
- # Agent session trigger events -> sandboxed coding agent sessions, plus the
- # session control routes, which have to be served from the process that owns
- # the live transports they act on.
- # Starts when both credentials are supplied:
- # `DAYTONA_API_KEY=... GITHUB_TOKEN=... just run_local`.
+ # Channel messages -> agent session trigger events -> sandboxed coding agent
+ # sessions, plus the session control routes, which have to be served from the
+ # process that owns the live transports they act on.
+ # Managed sandboxes require DAYTONA_API_KEY and GITHUB_TOKEN; trigger
+ # processing and external sessions run without them.
# ============================================================================
agent_harness_service:
<<: [*common-env, *rust-services-image]
command: ["/app/out/agent_harness_service"]
restart: on-failure
- profiles: ["agent-harness"]
# No host port: everything reaches this through the proxy, and a second
# local instance would collide on a fixed publish.
environment:
diff --git a/infra/stacks/agent-harness-service/agent_harness_service.ts b/infra/stacks/agent-harness-service/agent_harness_service.ts
index 483a65a3f2..e9267eadcf 100644
--- a/infra/stacks/agent-harness-service/agent_harness_service.ts
+++ b/infra/stacks/agent-harness-service/agent_harness_service.ts
@@ -47,9 +47,9 @@ type Args = {
* The agent harness service. Like agent-proxy before it, this component pins
* `desiredCount` to 1 and forces a stop-then-start deployment (min healthy
* 0%, max 100%) with no autoscaling: the harness owns the live agent-session
- * actors in process memory with no cross-instance sync, and its Kafka
- * consumer group must not split partitions across two momentarily-coexisting
- * tasks (see `AgentHarnessConsumerGroup` in `services/agent_harness_service`).
+ * actors in process memory with no cross-instance sync, and its Kafka consumer
+ * groups must not split partitions across two momentarily-coexisting tasks
+ * (see the consumer groups in `services/agent_harness_service`).
*/
export class AgentHarnessService extends pulumi.ComponentResource {
public role: aws.iam.Role;
@@ -158,7 +158,8 @@ export class AgentHarnessService extends pulumi.ComponentResource {
);
// Producer/consumer access to the macro event Kafka cluster: the harness
- // consumes `macro.agent_sessions` and publishes channel side effects.
+ // consumes `macro.channels` and `macro.agent_sessions`, publishes agent
+ // triggers, and publishes channel side effects.
new aws.iam.RolePolicyAttachment(
`${BASE_NAME}-role-kafka-client-att-${stack}`,
{
diff --git a/services/agent_harness_service/Cargo.toml b/services/agent_harness_service/Cargo.toml
index e7740216b3..d3697d809e 100644
--- a/services/agent_harness_service/Cargo.toml
+++ b/services/agent_harness_service/Cargo.toml
@@ -56,6 +56,6 @@ macro_env_var = { path = "../../crates/macro_env_var" }
macro_uuid = { path = "../../crates/macro_uuid" }
serde = { workspace = true }
sqlx = { workspace = true }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
tracing = { workspace = true }
workspace-hack = { version = "0.1", path = "../../crates/workspace-hack" }
diff --git a/services/agent_harness_service/src/main.rs b/services/agent_harness_service/src/main.rs
index c9d51aa602..84fb699156 100644
--- a/services/agent_harness_service/src/main.rs
+++ b/services/agent_harness_service/src/main.rs
@@ -3,11 +3,13 @@
//! The hexagon lives in `crates/agent_harness`; this binary is the shell
//! around it: it builds the Postgres repositories, the Daytona container
//! manager, and a channel service with the full side-effect stack for
-//! announcements, then drives the orchestrator from `macro.agent_sessions`.
+//! announcements, derives agent triggers from `macro.channels`, then drives
+//! the orchestrator from the resulting `macro.agent_sessions` events.
mod api;
mod bots_directory;
mod config;
+mod trigger;
use std::sync::Arc;
@@ -254,6 +256,13 @@ async fn main() -> anyhow::Result<()> {
}
});
+ // Keep trigger generation in this deployment while retaining Kafka as the
+ // boundary between channel events and harness commands.
+ let mut trigger = tokio::spawn(trigger::supervise(
+ pool.clone(),
+ config.kafka_brokers.as_ref().to_owned(),
+ ));
+
// The consumer: every agent-session event, filtered to our bot.
let consumer =
KafkaEventConsumer::<AgentHarnessConsumerGroup>::from_env(config.kafka_brokers.as_ref())?;
@@ -281,6 +290,13 @@ async fn main() -> anyhow::Result<()> {
tracing::info!("agent harness service shutting down");
break;
}
+ result = &mut trigger => {
+ run_error = Some(match result {
+ Ok(()) => anyhow::anyhow!("agent trigger stopped unexpectedly"),
+ Err(error) => anyhow::anyhow!("agent trigger task failed: {error}"),
+ });
+ break;
+ }
result = consumer.recv() => {
let message = match result {
Ok(message) => message,
@@ -363,6 +379,7 @@ async fn main() -> anyhow::Result<()> {
}
http.abort();
+ trigger.abort();
container_shutdown.shutdown_all().await;
while let Some(result) = tasks.join_next().await {
diff --git a/services/agent_harness_service/src/trigger.rs b/services/agent_harness_service/src/trigger.rs
new file mode 100644
index 0000000000..d41d4e63f4
--- /dev/null
+++ b/services/agent_harness_service/src/trigger.rs
@@ -0,0 +1,124 @@
+//! Channel-message consumer that emits agent-session trigger events.
+
+use agent_session::outbound::postgres::PgAgentSessionRepo;
+use agent_trigger::domain::service::{AgentBotLookup, AgentTriggerService};
+use anyhow::Context as _;
+use bot_id::BotId;
+use bots::domain::ports::BotRepo as _;
+use bots::outbound::pg_bots_repo::PgBotsRepo;
+use channels::domain::broker_events::{ChannelMacroEvent, ChannelTopicEvent};
+use kafka_util::{GroupName, KafkaEventConsumer};
+use macro_event_broker::{
+ KafkaConsumerAdapter, KafkaEventPublisher, MacroEvent as _, MacroEventBroker as _,
+ MacroEventBrokerService, MacroEventCollection as _, MacroEventConsumerService,
+};
+use rdkafka::consumer::CommitMode;
+use rdkafka::message::{BorrowedMessage, Message as _};
+use sqlx::PgPool;
+use tokio::time::{Duration, sleep};
+
+struct AgentTriggerConsumerGroup;
+
+impl GroupName for AgentTriggerConsumerGroup {
+ const GROUP_NAME: &'static str = "agent-trigger-service";
+}
+
+macro_event_broker::declare_topics!(DeclaredChannelEvent: ChannelMacroEvent);
+
+type TriggerKafkaAdapter = KafkaConsumerAdapter<AgentTriggerConsumerGroup, DeclaredChannelEvent>;
+type TriggerConsumer = MacroEventConsumerService<DeclaredChannelEvent, TriggerKafkaAdapter>;
+
+struct PgAgentBotLookup(PgBotsRepo);
+
+impl AgentBotLookup for PgAgentBotLookup {
+ async fn has_agent(&self, bot_id: BotId) -> agent_session::domain::error::Result<bool> {
+ self.0
+ .get_bot(bot_id)
+ .await
+ .map(|bot| bot.is_some_and(|bot| bot.has_agent))
+ .map_err(agent_session::domain::error::AgentSessionError::Unknown)
+ }
+}
+
+fn commit_message(consumer: &TriggerConsumer, message: &BorrowedMessage<'_>) -> anyhow::Result<()> {
+ consumer
+ .inner()
+ .commit_message(message, CommitMode::Sync)
+ .map_err(|error| anyhow::anyhow!("failed to commit channel event offset: {error:?}"))
+}
+
+/// Keeps the channel trigger consumer running across transient failures.
+pub async fn supervise(pool: PgPool, kafka_brokers: String) {
+ loop {
+ if let Err(error) = run(pool.clone(), kafka_brokers.clone()).await {
+ tracing::error!(error = ?error, "agent trigger stopped; restarting");
+ sleep(Duration::from_secs(1)).await;
+ }
+ }
+}
+
+async fn run(pool: PgPool, kafka_brokers: String) -> anyhow::Result<()> {
+ let trigger = AgentTriggerService::new(
+ PgAgentSessionRepo::new(pool.clone()),
+ PgAgentBotLookup(PgBotsRepo::new(pool)),
+ );
+ let publisher = MacroEventBrokerService::new(
+ KafkaEventPublisher::new(&kafka_brokers)?,
+ macro_event_broker::GlobalSpawner,
+ );
+ let consumer = KafkaEventConsumer::<AgentTriggerConsumerGroup>::from_env(&kafka_brokers)?;
+ let consumer = KafkaConsumerAdapter::<AgentTriggerConsumerGroup, ()>::new(consumer)
+ .subscribe::<DeclaredChannelEvent>()
+ .map_err(|error| anyhow::anyhow!("failed to subscribe to channel events: {error:?}"))?;
+ let consumer = TriggerConsumer::new(consumer);
+
+ tracing::info!(
+ topics = ?DeclaredChannelEvent::topics(),
+ group = AgentTriggerConsumerGroup::GROUP_NAME,
+ "agent trigger listening"
+ );
+
+ loop {
+ let message = match consumer.recv().await {
+ Ok(message) => message,
+ Err(error) => {
+ tracing::error!(error = ?error, "failed to receive channel event");
+ sleep(Duration::from_secs(1)).await;
+ continue;
+ }
+ };
+ let kafka_message = message.inner();
+ let event = match message.decode_payload() {
+ Ok(DeclaredChannelEvent::ChannelMacroEvent(event)) => event,
+ Err(error) => {
+ tracing::error!(
+ error = ?error,
+ partition = kafka_message.partition(),
+ offset = kafka_message.offset(),
+ "dropping undecodable channel event"
+ );
+ commit_message(&consumer, kafka_message)?;
+ continue;
+ }
+ };
+
+ let ChannelTopicEvent::MessagePosted(posted) = &event.event().event else {
+ commit_message(&consumer, kafka_message)?;
+ continue;
+ };
+ let yielded_events = trigger.evaluate(posted).await?;
+ if yielded_events.is_empty() {
+ tracing::debug!(message_id = %posted.message_id, "agent trigger yielded no event");
+ }
+ for yielded in yielded_events {
+ let json = serde_json::to_string(yielded.event())?;
+ tracing::info!(yielded_event = %json, "agent trigger yielded event");
+ let publish = publisher.send_event(&yielded)?;
+ publish
+ .await
+ .context("agent event publication task failed")??;
+ }
+
+ commit_message(&consumer, kafka_message)?;
+ }
+}
diff --git a/tooling/xtask/crates/xtask_local/src/local/inventory.rs b/tooling/xtask/crates/xtask_local/src/local/inventory.rs
index 696a638b4e..814c295de9 100644
--- a/tooling/xtask/crates/xtask_local/src/local/inventory.rs
+++ b/tooling/xtask/crates/xtask_local/src/local/inventory.rs
@@ -244,17 +244,6 @@ pub const RUST_SERVICES: &[RustService] = &[
opt_in: false,
no_default_features: true,
},
- RustService {
- compose_name: "agent_trigger_service",
- cargo_bin: "agent_trigger_service",
- package: "agent_trigger_service",
- host_port: None,
- path_prefix: None,
- is_websocket: false,
- modes: &[Mode::Local],
- opt_in: false,
- no_default_features: false,
- },
RustService {
compose_name: "agent_harness_service",
cargo_bin: "agent_harness_service",
@@ -262,8 +251,8 @@ pub const RUST_SERVICES: &[RustService] = &[
host_port: Some(Port::AgentHarness),
path_prefix: Some("/agent-harness"),
is_websocket: false,
- // Runs by default. LocalEnv reserves the credential keys so the
- // process-env overlay can supply them; startup requires both.
+ // Runs without sandbox credentials so channel triggers and external
+ // sessions remain available; managed spawns fail loudly when unarmed.
modes: &[Mode::Local],
opt_in: false,
no_default_features: false,
diff --git a/tooling/xtask/crates/xtask_local/src/local/inventory/test.rs b/tooling/xtask/crates/xtask_local/src/local/inventory/test.rs
index b7a9144731..e4f9d245b0 100644
--- a/tooling/xtask/crates/xtask_local/src/local/inventory/test.rs
+++ b/tooling/xtask/crates/xtask_local/src/local/inventory/test.rs
@@ -3,15 +3,14 @@ use super::*;
#[test]
fn local_binaries_are_unique_and_complete() {
let bins = local_binaries();
- // 16 distinct binaries (the bundled set, including the local-only
- // search_processing_service, agent services, and the seed_cli
+ // 15 distinct binaries (the bundled set, including the local-only
+ // search_processing_service, agent harness, and the seed_cli
// shipped for the gmail_forwarder sidecar).
- assert_eq!(bins.len(), 16, "{bins:?}");
+ assert_eq!(bins.len(), 15, "{bins:?}");
assert!(bins.contains(&"pubsub_workers"));
assert!(bins.contains(&"seed_cli"));
assert!(bins.contains(&"document_upload_finalizer_local_worker"));
assert!(bins.contains(&"search_processing_service"));
- assert!(bins.contains(&"agent_trigger_service"));
assert!(bins.contains(&"agent_harness_service"));
let mut sorted = bins.clone();
sorted.dedup();
@@ -30,11 +29,7 @@ fn nonobvious_crate_mappings() {
#[test]
fn workers_are_portless() {
- for name in [
- "agent_trigger_service",
- "document_upload_finalizer",
- "email_pubsub_workers",
- ] {
+ for name in ["document_upload_finalizer", "email_pubsub_workers"] {
let svc = RUST_SERVICES
.iter()
.find(|s| s.compose_name == name)
diff --git a/tooling/xtask/crates/xtask_local/src/local/mod.rs b/tooling/xtask/crates/xtask_local/src/local/mod.rs
index 681dce0317..654534bf1d 100644
--- a/tooling/xtask/crates/xtask_local/src/local/mod.rs
+++ b/tooling/xtask/crates/xtask_local/src/local/mod.rs
@@ -11,7 +11,6 @@
//! Design invariant: Docker never compiles Rust. Binaries are built on the host
//! and bind-mounted read-only into the runtime image at `/app/out`.
-use std::collections::BTreeMap;
use std::path::PathBuf;
pub mod arch;
@@ -557,17 +556,7 @@ fn prepare(
/// generated env. Shared by bring-up and the binary-reload restart.
fn compose_cmd(instance: &Instance, env: &env_layer::ResolvedEnv) -> Command {
let files = gen_compose::compose_files(instance);
- let mut command = gen_compose::docker_compose(instance, &files, &env.generated_path);
- if agent_harness_enabled(&env.merged) {
- command.args(["--profile", "agent-harness"]);
- }
- command
-}
-
-fn agent_harness_enabled(env: &BTreeMap<String, String>) -> bool {
- ["DAYTONA_API_KEY", "GITHUB_TOKEN"]
- .iter()
- .all(|key| env.get(*key).is_some_and(|value| !value.trim().is_empty()))
+ gen_compose::docker_compose(instance, &files, &env.generated_path)
}
fn build_aux_service_images(
diff --git a/tooling/xtask/crates/xtask_local/src/local/test.rs b/tooling/xtask/crates/xtask_local/src/local/test.rs
index 4bfe836257..d6fe65c6fa 100644
--- a/tooling/xtask/crates/xtask_local/src/local/test.rs
+++ b/tooling/xtask/crates/xtask_local/src/local/test.rs
@@ -1,5 +1,5 @@
use super::*;
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeSet;
/// Every mode whose spec we assert invariants over.
const MODES: &[Mode] = &[Mode::Local, Mode::Dev];
@@ -68,18 +68,3 @@ fn durable_bake_covers_every_repository_built_local_image() {
["proxy", "mailpit", "static_file_cdn"]
);
}
-
-#[test]
-fn agent_harness_requires_both_credentials() {
- let mut env = BTreeMap::new();
- assert!(!agent_harness_enabled(&env));
-
- env.insert("DAYTONA_API_KEY".into(), "daytona".into());
- assert!(!agent_harness_enabled(&env));
-
- env.insert("GITHUB_TOKEN".into(), "github".into());
- assert!(agent_harness_enabled(&env));
-
- env.insert("DAYTONA_API_KEY".into(), " ".into());
- assert!(!agent_harness_enabled(&env));
-}
diff --git a/tooling/xtask/crates/xtask_workflows/src/workflows/ensure_daytona_snapshot.rs b/tooling/xtask/crates/xtask_workflows/src/workflows/ensure_daytona_snapshot.rs
new file mode 100644
index 0000000000..35a80ec074
--- /dev/null
+++ b/tooling/xtask/crates/xtask_workflows/src/workflows/ensure_daytona_snapshot.rs
@@ -0,0 +1,63 @@
+//! `Ensure Daytona Snapshot` — creates the managed agent harness snapshot when
+//! it is missing. Generated into `ensure_daytona_snapshot.yml`.
+
+use gh_workflow::{
+ Concurrency, Event, Expression, Job, Level, Permissions, Push, Step, Workflow, WorkflowDispatch,
+};
+
+use crate::workflows::{runners, steps, vars};
+
+/// Build the workflow.
+pub fn ensure_daytona_snapshot() -> Workflow {
+ Workflow::new("Ensure Daytona Snapshot")
+ .permissions(Permissions {
+ contents: Some(Level::Read),
+ ..Default::default()
+ })
+ .on(Event::default()
+ .push(
+ Push::default()
+ .add_branch("main")
+ .add_path(xtask_paths::repo_glob!(
+ "crates/agent_harness/container/**"
+ ))
+ .add_path(xtask_paths::repo_glob!(
+ "crates/agent_harness/justfile"
+ ))
+ .add_path(xtask_paths::repo_glob!("nix/cloud-storage.nix"))
+ .add_path(xtask_paths::repo_glob!(
+ "tooling/xtask/crates/xtask_workflows/src/workflows/ensure_daytona_snapshot.rs"
+ ))
+ .add_path(xtask_paths::repo_glob!(
+ ".github/workflows/ensure_daytona_snapshot.yml"
+ )),
+ )
+ .workflow_dispatch(WorkflowDispatch::default()))
+ .concurrency(
+ Concurrency::new(Expression::new("${{ github.workflow }}")).cancel_in_progress(false),
+ )
+ .add_job("ensure-snapshot", ensure_snapshot())
+}
+
+fn ensure_snapshot() -> Job {
+ Job::default()
+ .name("Ensure macro-agent-harness snapshot")
+ .runs_on(runners::Runner::Small.to_string())
+ .add_step(steps::checkout(false, false))
+ .add_step(steps::mount_nix_cache_volume())
+ .add_step(steps::setup_nix())
+ .add_step(steps::setup_dev_shell())
+ .add_step(
+ Step::new("Ensure Daytona snapshot")
+ .run(indoc::indoc! {r#"
+ set -euo pipefail
+ if [[ -z "${DAYTONA_API_KEY:-}" ]]; then
+ echo "::error::DAYTONA_API_KEY repository secret is not configured"
+ exit 1
+ fi
+ just --justfile crates/agent_harness/justfile ensure-daytona
+ "#})
+ .shell("bash")
+ .add_env(("DAYTONA_API_KEY", vars::DAYTONA_API_KEY)),
+ )
+}
diff --git a/tooling/xtask/crates/xtask_workflows/src/workflows/mod.rs b/tooling/xtask/crates/xtask_workflows/src/workflows/mod.rs
index de957eba45..600aef5e72 100644
--- a/tooling/xtask/crates/xtask_workflows/src/workflows/mod.rs
+++ b/tooling/xtask/crates/xtask_workflows/src/workflows/mod.rs
@@ -34,6 +34,7 @@ mod deploy_preview;
mod deploy_sync_service;
mod deploy_web_app;
mod docs_check;
+mod ensure_daytona_snapshot;
mod path_validation;
mod preview_fly;
mod pulumi_preview_pr;
@@ -232,6 +233,11 @@ const WORKFLOWS: &[WorkflowFile] = &[
file_name: "deploy_web_app.yml",
render_yaml: || render_patched(deploy_web_app::deploy_web_app, deploy_web_app::patch),
},
+ WorkflowFile {
+ slug: "ensure_daytona_snapshot",
+ file_name: "ensure_daytona_snapshot.yml",
+ render_yaml: || render_gh_workflow(ensure_daytona_snapshot::ensure_daytona_snapshot)(),
+ },
WorkflowFile {
slug: "pulumi_preview_pr",
file_name: "pulumi_preview_pr.yml",
diff --git a/tooling/xtask/crates/xtask_workflows/src/workflows/vars.rs b/tooling/xtask/crates/xtask_workflows/src/workflows/vars.rs
index a732add369..03cb5f67af 100644
--- a/tooling/xtask/crates/xtask_workflows/src/workflows/vars.rs
+++ b/tooling/xtask/crates/xtask_workflows/src/workflows/vars.rs
@@ -14,6 +14,7 @@ macro_rules! secret {
secret!(AWS_ACCESS_KEY);
secret!(AWS_SECRET_ACCESS_KEY);
secret!(CLOUDFLARE_API_TOKEN);
+secret!(DAYTONA_API_KEY);
secret!(DD_API_KEY);
secret!(DD_APP_KEY);
secret!(DOPPLER_PREVIEW_TOKEN);