Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
//! The service's composition root: reads config and wires every adapter and
//! domain service into the HTTP server and its background workers.
use crate::{
api::{
self, MACRO_INTERNAL_USER_ID,
context::{
ApiContext, AuthorizationService, DocumentStorageServiceAuthKey, DssOwnedPurgeState,
TaskPropertiesAdapter,
},
},
config::{
self, CalEventTypeContentNamesKey, CalWebhookSecretKey, Config, Environment,
MetaAccessToken, MetaPixelId, MetaTestEventCode,
},
outbound,
service::{self, s3::S3},
};
use account_manager::{
domain::service::AccountManagerServiceImpl,
inbound::axum_router::AccountManagerRouterState,
outbound::{
dm_delivery::DmAccountManagerDelivery, pg_account_manager_repo::PgAccountManagerRepo,
},
};
use agent_session_realtime::{
domain::service::AgentSessionLogConsumerService,
outbound::redis_stream::consumer::RedisLogStreamConsumer,
};
use analytics_client::{AnalyticsClient, AnalyticsClientConfig, MetaConfig};
use anyhow::Context;
use bots::{domain::service::BotServiceImpl, outbound::pg_bots_repo::PgBotsRepo};
use cal::{
domain::service::{CalConfig, CalEventMeta, CalWebhookServiceImpl},
inbound::cal_webhook_router::CalWebhookRouterState,
outbound::analytics_client::AnalyticsClientSink,
};
use calendar_events::domain::reminder_dispatch::CalendarReminderDispatchService;
use calendar_events::inbound::axum_router::CalendarRouterState;
use calendar_events::inbound::dispatch_worker::CalendarReminderDispatchWorker;
use calendar_events::outbound::notification_notifier::NotificationCalendarReminderNotifier;
use calendar_events::outbound::sqs_dispatch_queue::SqsCalendarDispatchQueue;
use call::{
domain::service::CallServiceImpl,
inbound::axum_router::{CallRouterState, InternalCallRouterState, WebhookRouterState},
outbound::{
ai_call_summarizer::AiCallSummarizer,
livekit_rtc_client::LivekitRtcClient,
pg_call_repo::PgCallRepo,
pg_voice_repo::PgVoiceRepo,
s3_recording_storage::{RecordingCloudFrontConfig, S3RecordingStorage},
},
};
use channel_labels::{
domain::service::ChannelLabelsServiceImpl, inbound::axum_router::ChannelLabelsRouterState,
outbound::pg_channel_labels_repo::PgChannelLabelsRepo,
};
use channels::{
domain::{
list_service::ChannelListServiceImpl,
service::ChannelServiceImpl,
side_effects::{ChannelSideEffectService, SpawnedChannelEventDispatcher},
},
inbound::{axum_router::ChannelsRouterState, list_router::ChannelListRouterState},
outbound::{
connection_gateway_realtime::ConnectionGatewayChannelRealtimePublisher,
contacts_dispatcher::ContactsChannelDispatcher,
notification_sender::{NotificationChannelSender, NotificationReaderCompletion},
pg_channel_reference_share_permissions::PgChannelReferenceSharePermissions,
pg_channels_repo::PgChannelsRepo,
pg_side_effect_context::PgChannelSideEffectContext,
},
};
use collab_surface::inbound::axum_router::CollabSurfaceRouterState;
use connection::{
domain::service::ConnectionServiceImpl,
outbound::connection_gateway_client::ConnectionGatewayImpl,
};
use connection_gateway_client::client::ConnectionGatewayClient;
use documents_hex::domain::models::CloudFrontConfig;
use documents_hex::domain::service::DocumentServiceImpl;
use documents_hex::inbound::axum_router::DocumentRouterState;
use documents_hex::outbound::pg_document_repo::PgDocumentRepo;
use documents_hex::outbound::s3_upload_url::S3UploadUrlAdapter;
use dynamodb_client::DynamodbClient;
use email::{
domain::{ports::ReadonlyEmailPreviewAdapter, service::EmailServiceImpl},
outbound::EmailPgRepo,
};
use embedding::embedding_provider::openai::TextEmbedding3Small;
use entity_registry::OwnerGrantPolicy;
use entity_registry_db_utils::OwnedEntityRegistrar;
use favorites::{
domain::{mutation_service::FavoritesMutationServiceImpl, service::FavoritesServiceImpl},
inbound::axum_router::FavoritesRouterState,
outbound::pg_favorites_repo::PgFavoritesRepo,
};
use foreign_entity::{
domain::service::ForeignEntityServiceImpl, inbound::axum_router::ForeignEntityRouterState,
outbound::pg_foreign_entity_repo::PgForeignEntityRepo,
};
use frecency::{domain::services::FrecencyQueryServiceImpl, outbound::postgres::FrecencyPgStorage};
use github::domain::service::{
GithubSyncConfig, GithubSyncServiceImpl, InstallationTokenConfig, InstallationTokenService,
PullRequestIndexService,
};
use github::inbound::pull_request_index_router::PullRequestIndexRouterState;
use github::outbound::connection_gateway_realtime::ConnectionGatewayGithubRealtime;
use github::outbound::github_sync_client::GithubSyncClientImpl;
use github::outbound::pg_github_sync_repo::PgGithubSyncRepo;
use github::outbound::pull_request_diff::GithubPullRequestDiffClient;
use github_pull_requests::{
domain::service::{
GithubPullRequestChangesServiceImpl, GithubPullRequestChangesetStore,
GithubPullRequestServiceImpl,
},
inbound::{
axum_router::GithubPullRequestRouterState,
changes_router::GithubPullRequestChangesRouterState,
},
outbound::{
pg_github_pull_request_repo::PgGithubPullRequestRepo,
s3_patch_store::S3GithubPullRequestPatchStore,
},
};
use graphql_scheduled_action::ScheduledActionGraphqlContext;
use harnesses::outbound::pg_harness_repo::PgHarnessRepo;
use initiative::{
domain::service::InitiativeServiceImpl, inbound::axum_router::InitiativeRouterState,
outbound::PgInitiativeRepo,
};
use lexical_client::LexicalClient;
use macro_auth::middleware::decode_jwt::JwtValidationArgs;
use macro_authorization::{
InternalAuthConfig, MacroAuthJwtValidator, MacroAuthorizationServiceImpl,
MacroAuthorizationState, PgBotAuthorizationRepo, PgBotAuthorizer, PgHarnessAuthorizationRepo,
PgHarnessAuthorizer, PgUserApiKeyAuthorizationRepo, PgUserApiKeyAuthorizer,
};
use macro_env_var::maybe_env_vars;
use macro_event_broker::{KafkaEventPublisher, MacroEventBrokerService};
use macro_service_urls::{
AiEditingWorkerUrl, ConnectionGatewayUrl, LexicalServiceUrl, StaticFileServiceUrl,
SyncServiceUrl,
};
use macro_sha_count_client::Redis;
use notification::domain::service::{
NotificationReaderService, PlatformArnConfig, SqsNotificationIngress,
WebSocketNotificationConsumerService,
};
use notification::outbound::{notification_consumer::NotificationTopicConsumer, queue::SqsQueue};
use opensearch_client::OpensearchClient;
use projects_hex::{
domain::service::ProjectServiceImpl,
inbound::axum_router::ProjectRouterState,
outbound::{
DynamoBulkUploadAdapter, PgProjectRepo, S3ProjectUploadAdapter, ShaCountAdapter,
SqsProjectSearchIndexer,
},
};
use properties::{
NotificationServiceImpl, PermissionServiceImpl, PropertiesPgRepo, PropertiesServiceImpl,
};
use rate_limit::{RateLimitServiceImpl, RedisRateLimitAdapter};
use reminders::{
domain::service::dispatch::ReminderDispatchService,
inbound::{axum_router::RemindersRouterState, dispatch_worker::DispatchWorker},
outbound::{
notification_notifier::NotificationReminderNotifier, pg_reminders_repo::PgRemindersRepo,
sqs_dispatch_queue::SqsDispatchQueue,
},
};
use scheduled_action::domain::read_service::ScheduledActionReadServiceImpl;
use scheduled_action::outbound::pg_scheduled_action_repo::PgScheduledActionRepo;
use secretsmanager_client::SecretManager;
use soup::{
domain::service::SoupImpl, inbound::axum_router::SoupRouterState,
outbound::pg_soup_repo::PgSoupRepo,
};
use soup_realtime::{
domain::service::{SoupRealtimeConsumerService, SoupRealtimeServiceImpl},
outbound::{
entity_access::EntityAccessExpander, kafka_publisher::KafkaSoupRealtimePublisher,
soup_consumer::SoupTopicConsumer,
},
};
use sqlx::postgres::PgPoolOptions;
use std::{sync::Arc, time::Duration};
use sync_service_client::SyncServiceClient;
use system_properties::{PgSystemPropertiesRepository, SystemPropertiesServiceImpl};
use task_dedup::{
TaskDedupService,
outbound::{
cohere::CohereReranker,
connection_gateway::ConnectionGatewayTaskDedupNotifier,
judge::AgentDuplicateJudge,
postgres::{PgTaskMatchRepo, PgTaskVectorDb},
},
};
use tokio_util::{sync::CancellationToken, task::TaskTracker};
use user_api_key::{
domain::service::UserApiKeyServiceImpl, inbound::axum_router::UserApiKeyRouterState,
outbound::pg_user_api_keys_repo::PgUserApiKeysRepo,
};
const SOUP_CONSUMER_RESTART_MAX_DELAY_SECS: u64 = 60;
const SOUP_CONSUMER_RESTART_ALERT_THRESHOLD: u32 = 5;
const DEFAULT_POSTHOG_HOST: &str = "https://us.i.posthog.com";
fn soup_consumer_restart_delay(consecutive_failures: u32) -> Duration {
let exponent = consecutive_failures.saturating_sub(1).min(6);
Duration::from_secs((1_u64 << exponent).min(SOUP_CONSUMER_RESTART_MAX_DELAY_SECS))
}
maybe_env_vars! {
struct AppleBundleId;
struct SnsApnsVoipPlatformArn;
}
/// Build the service from the environment and serve until shutdown.
// Not a `pub async fn`: see CS-73.
pub fn run() -> impl Future<Output = anyhow::Result<()>> {
run_server()
}
async fn run_server() -> anyhow::Result<()> {
let env = Environment::new_or_prod();
let aws_config = macro_aws_config::get_macro_aws_config().await;
let secretsmanager_client = secretsmanager_client::SecretsManager::new(
aws_sdk_secretsmanager::Client::new(&aws_config),
);
// Parse our configuration from the environment, then resolve any secret-manager backed values.
let config = Config::from_env()
.context("expected to be able to generate config")?
.resolve_remote_secrets(env, &secretsmanager_client)
.await
.context("expected to be able to resolve config secrets")?;
let non_user_owners = config.non_user_owners()?;
tracing::trace!("initialized config");
// Per task. Normally each task runs about one query at a time; a larger
// max only lets a slow database pile up more sessions.
let (min_connections, max_connections): (u32, u32) = match config.environment {
Environment::Production => (10, 50),
Environment::Develop => (25, 100),
Environment::Local => (15, 50),
};
let db = PgPoolOptions::new()
.min_connections(min_connections)
.max_connections(max_connections)
.connect(&config.database_url)
.await
.context("could not connect to db")?;
tracing::trace!(
min_connections,
max_connections,
"initialized db connection"
);
let (readonly_min_connections, readonly_max_connections) = match config.environment {
// Once all tasks use this cap, three dev tasks allow 60 replica sessions,
// or 120 during a full rolling overlap.
// Keep excess reads queued in the service instead of exhausting replica memory.
Environment::Develop => (2, 20),
Environment::Production | Environment::Local => (min_connections, max_connections),
};
let readonly_db = match PgPoolOptions::new()
.min_connections(readonly_min_connections)
.max_connections(readonly_max_connections)
.connect(&config.database_url_readonly)
.await
{
Ok(pool) => {
tracing::trace!(
min_connections = readonly_min_connections,
max_connections = readonly_max_connections,
"initialized readonly db connection"
);
pool
}
Err(e) => {
tracing::warn!(error=?e, "failed to connect to readonly db, falling back to primary");
db.clone()
}
};
let dynamo_db = aws_sdk_dynamodb::Client::new(&aws_config);
let dynamodb_client = DynamodbClient::new_from_client(
dynamo_db.clone(),
Some(config.bulk_upload_requests_table.as_ref().to_string()),
);
tracing::trace!("initialized dynamodb client");
let s3_client = macro_aws_config::s3_client().await;
tracing::trace!("initialized s3 client");
let search_event_queue = macro_queues::SearchEventQueue::new();
let document_delete_queue = macro_queues::DocumentDeleteQueue::new();
let contacts_queue = macro_queues::ContactsQueue::new();
let notification_queue = macro_queues::NotificationIngressQueue::new();
let gmail_ops_queue = macro_queues::GmailOpsQueue::new();
let email_scheduled_queue = macro_queues::EmailScheduledQueue::new();
let reminder_dispatch_queue = macro_queues::ReminderDispatchQueue::new();
let calendar_reminder_dispatch_queue = macro_queues::CalendarReminderDispatchQueue::new();
let sqs_client = sqs_client::SQS::new(aws_sdk_sqs::Client::new(&aws_config))
.search_event_queue(&search_event_queue)
.document_delete_queue(&document_delete_queue)
.gmail_ops_queue(&gmail_ops_queue)
.gmail_label_write_batches(config.gmail_label_write_batches_enabled)
.email_scheduled_queue(&email_scheduled_queue);
let webhook_event_queue = webhook::outbound::SqsWebhookQueue::new(
Arc::new(sqs_client.clone()),
macro_queues::WebhookEventQueue::new().to_string(),
config.webhook_queue_max_messages,
config.webhook_queue_wait_time_seconds,
);
let contacts_ingress = Arc::new(contacts::domain::service::SqsContactsIngress {
queue: contacts::outbound::ingress::SqsContactsQueue::new(
aws_sdk_sqs::Client::new(&aws_config),
contacts_queue.to_string(),
),
});
tracing::trace!("initialized sqs client");
// Redis handles it own connection pool internally. Each time we use redis
// we should be using redis_client.get_connection() to grab a specific connection
let redis_client = redis::Client::open(config.redis_uri.to_string().as_ref())
.expect("could not connect to redis client");
match redis_client.get_connection().is_err() {
true => {
tracing::error!("unable to connect to redis");
}
false => {
tracing::trace!("initialized redis connection");
}
}
let dss_auth_key = DocumentStorageServiceAuthKey::new()?;
let conn_gateway_client = ConnectionGatewayClient::new(
config.internal_api_key.to_string(),
ConnectionGatewayUrl::new()?.to_string(),
);
let sync_service_client = Arc::new(SyncServiceClient::new(
config.sync_service_auth_key.as_ref().to_string(),
SyncServiceUrl::new()?.to_string(),
));
let lexical_client = Arc::new(LexicalClient::new(
config.internal_api_key.to_string(),
LexicalServiceUrl::new()?.to_string(),
));
let jwt_validation_args =
JwtValidationArgs::new_with_secret_manager(config.environment, &secretsmanager_client)
.await?;
let consumer_cancellation_token = CancellationToken::new();
let consumer_tracker = TaskTracker::new();
let event_broker_tracker = TaskTracker::new();
let import_jobs = ai_tools::ImportJobs::new();
let macro_event_broker = MacroEventBrokerService::new(
KafkaEventPublisher::new(config.kafka_brokers.as_ref())
.context("failed to create kafka event publisher")?,
event_broker_tracker.clone(),
);
let bots_repo = PgBotsRepo::new(db.clone());
// The agent API checks a newly selected MCP app against Pipedream's
// directory, the same check the ConfigureAgent tool makes.
let bots_service = BotServiceImpl::new(bots_repo, macro_event_broker.clone()).with_mcp_apps(
ai_tools::PipedreamMcpAppCatalog::new(ai_tools::pipedream_client_from_env()?),
);
let authorization_service: AuthorizationService = MacroAuthorizationServiceImpl::new(
MacroAuthJwtValidator::new(jwt_validation_args.clone()),
InternalAuthConfig {
api_key: dss_auth_key.as_ref().to_string(),
default_user_id: Some(MACRO_INTERNAL_USER_ID.to_string()),
},
PgBotAuthorizer::new(PgBotAuthorizationRepo::new(db.clone())),
PgUserApiKeyAuthorizer::new(PgUserApiKeyAuthorizationRepo::new(db.clone())),
)
.with_harness_authorizer(PgHarnessAuthorizer::new(PgHarnessAuthorizationRepo::new(
db.clone(),
)));
let authorization_state = MacroAuthorizationState::new(Arc::new(authorization_service));
let harnesses_service =
harnesses::domain::service::HarnessServiceImpl::new(PgHarnessRepo::new(db.clone()));
// Initialize OpenSearch client
let opensearch_client = OpensearchClient::new(
config.opensearch_url.to_string(),
config.opensearch_username.to_string(),
config.opensearch_password.to_string(),
)
.context("unable to create opensearch client")?;
if let Err(e) = opensearch_client.health().await {
tracing::error!(error=?e, "error connecting to opensearch");
return Err(e);
}
tracing::trace!("initialized opensearch client");
let frecency_storage = FrecencyPgStorage::new(db.clone());
let frecency_service = FrecencyQueryServiceImpl::new(frecency_storage.clone());
// DSS only reads CRM rows — no-op resolver keeps reqwest/scraper
// out of this binary.
let crm_service = crm::domain::service::CrmServiceImpl::new(
crm::outbound::companies_repo::CompaniesRepositoryImpl::new(db.clone()),
crm::outbound::no_op_resolver::NoOpCompanyMetadataResolver,
);
let entity_access_service = Arc::new(
entity_access::domain::service::EntityAccessServiceImpl::new(
entity_access::outbound::PgAccessRepository::new(db.clone()),
),
);
let email_service = EmailServiceImpl::new(
EmailPgRepo::new(db.clone()),
frecency_service.clone(),
sqs_client.clone(),
crm_service.clone(),
entity_access_management::domain::service::EntityAccessManagementServiceImpl::new(
entity_access_management::outbound::PgRepository::new(db.clone()),
),
config.sent_undo_delay_secs,
)
.with_sender_provider(email::outbound::GmailSenderProvider::new(
gmail_client::GmailClient::without_watch(),
email::outbound::GmailTokenProviderImpl::lazy(
redis_client.clone(),
Arc::new(authentication_service_client::AuthServiceClient::new(
config
.authentication_service_secret_key
.as_ref()
.to_string(),
macro_service_urls::AuthServiceUrl::new()?.to_string(),
)),
),
))
.with_shared_thread_replies(email::outbound::EntityAccessSharedThreadReplies::new(
db.clone(),
(*entity_access_service).clone(),
))
.with_macro_event_broker(macro_event_broker.clone());
let readonly_email_service = ReadonlyEmailPreviewAdapter(
EmailServiceImpl::new(
EmailPgRepo::new(readonly_db.clone()),
frecency_service.clone(),
sqs_client.clone(),
crm_service.clone(),
entity_access_management::domain::service::EntityAccessManagementServiceImpl::new(
entity_access_management::outbound::PgRepository::new(readonly_db.clone()),
),
0,
)
.with_macro_event_broker(macro_event_broker.clone()),
);
let system_properties_service =
SystemPropertiesServiceImpl::new(PgSystemPropertiesRepository::new(db.clone()));
let ingress_queue = SqsQueue::new(
aws_sdk_sqs::Client::new(&aws_config),
notification_queue.to_string(),
);
let notification_ingress_service = Arc::new(SqsNotificationIngress {
queue: ingress_queue.clone(),
});
let graphql_notification_reader: Arc<ai_tools::ToolNotificationService> =
Arc::new(NotificationReaderService {
repository: notification::outbound::repository::DbNotificationRepository::new(
db.clone(),
),
queue: ai_tools::ToolNotificationQueue::Sqs(ingress_queue.clone()),
sns_endpoint: ai_tools::NoOpSnsEndpointManager,
platform_config: PlatformArnConfig {
apns_platform_arn: String::new(),
fcm_platform_arn: String::new(),
apns_voip_platform_arn: String::new(),
},
realtime: notification::domain::ports::NoopNotificationRealtimePublisher,
});
tracing::trace!("initialized notification ingress service");
let permission_checker = PermissionServiceImpl::new(db.clone(), entity_access_service.clone());
let notification_service = NotificationServiceImpl::new(
SqsNotificationIngress {
queue: ingress_queue,
},
db.clone(),
);
let properties_service = Arc::new(
PropertiesServiceImpl::new(
PropertiesPgRepo::new(db.clone()),
Some(permission_checker),
Some(notification_service),
)
.with_event_broker(macro_event_broker.clone())
.with_initiative_assignees(Arc::new(
initiative::domain::assignees::InitiativeAssignees::new(PgInitiativeRepo::new(
db.clone(),
)),
)),
);
// Create the channel list service used by soup.
// Create the legacy channel list router state for routes mounted under /comms.
let agent_dm_profiles = Arc::new(outbound::agent_dm_authorizer::AgentDmProfileReader::new(
PgChannelsRepo::new(db.clone()),
PgBotsRepo::new(db.clone()),
));
let channel_list_state = ChannelListRouterState::new(
ChannelListServiceImpl::new(
PgChannelsRepo::new(db.clone()),
PgChannelsRepo::new(db.clone()),
frecency_storage.clone(),
)
.with_agent_dm_profiles(agent_dm_profiles.clone()),
authorization_state.clone(),
);
let s3 = Arc::new(S3::new(
s3_client,
config.document_storage_bucket.as_ref(),
config.docx_document_upload_bucket.as_ref(),
config.upload_staging_bucket.as_ref(),
));
let system_properties_service = Arc::new(system_properties_service);
let owned_entity_registrar =
OwnedEntityRegistrar::new(OwnerGrantPolicy::new(PgBotsRepo::new(db.clone())));
let document_repo = PgDocumentRepo::new(db.clone(), owned_entity_registrar.clone());
let cloudfront_config = CloudFrontConfig {
distribution_url: config
.document_storage_service_cloudfront_distribution_url
.as_ref()
.to_string(),
signer_public_key_id: config
.document_storage_service_cloudfront_signer_public_key_id
.as_ref()
.to_string(),
signer_private_key: config
.document_storage_service_cloudfront_signer_private_key
.as_ref()
.to_string(),
presigned_url_expiry_seconds: config.document_storage_service_presigned_url_expiry_seconds,
browser_cache_expiry_seconds: config
.document_storage_service_presigned_url_browser_cache_expiry_seconds,
};
let s3_upload_adapter = S3UploadUrlAdapter::new(
macro_aws_config::s3_client().await,
config.document_storage_bucket.as_ref(),
config.docx_document_upload_bucket.as_ref(),
);
let markdown_initializer =
documents_hex::outbound::markdown_init::LexicalSyncMarkdownInitializer::detached(
lexical_client.as_ref().clone(),
sync_service_client.as_ref().clone(),
);
let connection_gateway = Arc::new(ConnectionGatewayImpl::new(conn_gateway_client.clone()));
let access_requests_repo =
Arc::new(access_requests::outbound::postgres::PgRequestRepository::new(db.clone()));
let access_requests_service =
Arc::new(access_requests::domain::service::AccessRequestService::new(
access_requests_repo.clone(),
entity_access_service.clone(),
access_requests::domain::ports::SystemClock,
));
consumer_tracker.spawn(access_requests::inbound::dispatch::run(
access_requests_repo,
crate::outbound::access_requests::AccessRequestDelivery {
withdrawal: Arc::new(
notification::outbound::withdrawal::PgNotificationWithdrawal(db.clone()),
),
ingress: notification_ingress_service.clone(),
reader: graphql_notification_reader.clone(),
connection: connection_gateway.clone(),
},
consumer_cancellation_token.clone(),
));
let connection_service =
ConnectionServiceImpl::new(entity_access_service.clone(), connection_gateway.clone());
let entity_access_management_service =
entity_access_management::domain::service::EntityAccessManagementServiceImpl::new(
entity_access_management::outbound::PgRepository::new(db.clone()),
);
let chat_mutation_service =
Arc::new(chat::domain::service::ChatServiceImpl::new_without_tools(
chat::outbound::postgres::PgChatRepo::new(db.clone(), owned_entity_registrar.clone()),
entity_access_management_service.clone(),
));
let project_service = Arc::new(ProjectServiceImpl::new(
PgProjectRepo::new(db.clone(), owned_entity_registrar.clone()),
S3ProjectUploadAdapter::new(
macro_aws_config::s3_client().await,
config.document_storage_bucket.as_ref(),
config.docx_document_upload_bucket.as_ref(),
config.upload_staging_bucket.as_ref(),
),
DynamoBulkUploadAdapter::new(dynamodb_client.clone()),
ShaCountAdapter::new(Redis::new(redis_client.clone())),
entity_access_management_service.clone(),
SqsProjectSearchIndexer::new(Arc::new(sqs_client.clone()), macro_event_broker.clone()),
if cfg!(feature = "local") {
Some(uuid::uuid!("d50676e2-0a12-4c62-bc07-4b1cb6d8e9bc"))
} else {
None
},
macro_event_broker.clone(),
));
let document_service = Arc::new(DocumentServiceImpl::new(
document_repo,
cloudfront_config,
sync_service_client.as_ref().clone(),
s3_upload_adapter,
TaskPropertiesAdapter {
system_properties: system_properties_service.clone(),
properties: properties_service.clone(),
entity_access_service: entity_access_service.clone(),
},
connection_service,
entity_access_management_service.clone(),
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
macro_event_broker.clone(),
));
let foreign_entity_service = Arc::new(ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(
db.clone(),
)));
let github_sync_service_impl = GithubSyncServiceImpl::new(
GithubSyncConfig {
webhook_secret: config.github_webhook_secret_key.as_ref().to_string(),
github_sync_app_url: config.github_sync_app_url.to_string(),
sync_app_pem: config.github_sync_app_pem_secret_key.as_ref().to_string(),
sync_app_client_id: config.github_sync_app_client_id.to_string(),
sync_app_client_secret: config.github_sync_app_client_secret.to_string(),
installation_state_secret: config.github_installation_state_secret.to_string(),
},
document_service.clone(),
Arc::new(
GithubPullRequestServiceImpl::new(
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
PgGithubPullRequestRepo::new(db.clone()),
)
.with_event_publisher(
github_pull_requests::broker::BrokerGithubPullRequestPublisher(
macro_event_broker.clone(),
),
),
),
(*notification_ingress_service).clone(),
PgGithubSyncRepo::new(db.clone()),
GithubSyncClientImpl::default(),
ConnectionGatewayGithubRealtime::new(conn_gateway_client.clone()),
)
.with_webhook_publisher(github::broker::BrokerGithubWebhookPublisher(
macro_event_broker.clone(),
));
let github_pull_request_index_state = PullRequestIndexRouterState {
service: Arc::new(PullRequestIndexService::new(
InstallationTokenConfig {
client_id: config.github_sync_app_client_id.to_string(),
private_key_pem: config.github_sync_app_pem_secret_key.as_ref().to_string(),
},
PgGithubSyncRepo::new(db.clone()),
GithubSyncClientImpl::default(),
GithubPullRequestServiceImpl::new(
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
PgGithubPullRequestRepo::new(db.clone()),
),
)),
authorization_state: authorization_state.clone(),
};
let github_pull_request_state = GithubPullRequestRouterState::new(
Arc::new(GithubPullRequestServiceImpl::new(
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
PgGithubPullRequestRepo::new(db.clone()),
)),
entity_access_service.clone(),
authorization_state.clone(),
);
let github_pull_request_changes_state = GithubPullRequestChangesRouterState::new(
Arc::new(GithubPullRequestChangesServiceImpl::new(
GithubPullRequestServiceImpl::new(
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
PgGithubPullRequestRepo::new(db.clone()),
),
GithubPullRequestChangesetStore::new(
GithubPullRequestDiffClient::new(InstallationTokenService::new(
InstallationTokenConfig {
client_id: config.github_sync_app_client_id.to_string(),
private_key_pem: config.github_sync_app_pem_secret_key.as_ref().to_string(),
},
PgGithubSyncRepo::new(db.clone()),
GithubSyncClientImpl::default(),
)),
PgGithubPullRequestRepo::new(db.clone()),
S3GithubPullRequestPatchStore::new(
macro_aws_config::s3_client().await,
config.github_pull_request_patch_bucket.to_string(),
),
),
)),
entity_access_service.clone(),
authorization_state.clone(),
);
let foreign_entity_state = ForeignEntityRouterState::new(
foreign_entity_service.clone(),
entity_access_service.clone(),
authorization_state.clone(),
);
// Cal.com webhooks → Meta Lead events. Both secrets are loaded here
// (rather than on Config) to keep cal/Meta wiring colocated.
let cal_webhook_secret = secretsmanager_client
.get_maybe_secret_value(env, CalWebhookSecretKey::new()?)
.await?;
let cal_event_type_content_names_secret = secretsmanager_client
.get_maybe_secret_value(env, CalEventTypeContentNamesKey::new()?)
.await?;
let analytics_client = Arc::new(AnalyticsClient::new(AnalyticsClientConfig {
google_analytics: None,
meta: Some(MetaConfig {
pixel_id: MetaPixelId::new()?.as_ref().to_string(),
access_token: MetaAccessToken::new()?.as_ref().to_string(),
test_event_code: MetaTestEventCode::new().map(|v| v.as_ref().to_string()),
}),
posthog: None,
}));
let cal_event_type_meta: std::collections::HashMap<u64, CalEventMeta> =
serde_json::from_str(cal_event_type_content_names_secret.as_ref())
.context("CalEventTypeContentNames secret must be a JSON object mapping eventTypeId (u64) to { content_name: string, value: number (USD) }")?;
let cal_webhook_service = CalWebhookServiceImpl::new(
CalConfig {
webhook_secret: cal_webhook_secret.as_ref().to_string(),
event_type_meta: cal_event_type_meta,
},
AnalyticsClientSink::new(analytics_client.clone()),
);
let cal_webhook_state = CalWebhookRouterState::new(cal_webhook_service);
// Call service (LiveKit)
let transcription_agent_name = config
.livekit_transcription_agent_name
.value()
.map(|v| v.to_owned());
let internal_call_secret = config.internal_call_secret.value().map(|v| v.to_owned());
anyhow::ensure!(
transcription_agent_name.is_none() || internal_call_secret.is_some(),
"LIVEKIT_TRANSCRIPTION_AGENT_NAME is set but INTERNAL_CALL_SECRET is missing — \
the transcription agent will not be able to submit transcripts"
);
let livekit_rtc_client = LivekitRtcClient::new(
config.livekit_server_url.as_ref(),
config.livekit_api_key.as_ref(),
config.livekit_api_secret.as_ref(),
transcription_agent_name,
);
let call_connection_service =
ConnectionServiceImpl::new(entity_access_service.clone(), connection_gateway.clone());
let call_repo = PgCallRepo::new(db.clone());
let egress_config = match (
config::CallRecordingS3Bucket::new(),
config::CallRecordingS3Region::new(),
config::CallRecordingS3AccessKey::new(),
config::CallRecordingS3Secret::new(),
) {
(Some(bucket), Some(region), Some(access_key), Some(secret)) => {
tracing::info!(bucket = bucket.as_ref(), "call recording enabled");
Some(call::domain::models::EgressS3Config {
bucket: bucket.as_ref().to_string(),
region: region.as_ref().to_string(),
access_key: access_key.as_ref().to_string(),
secret: secret.as_ref().to_string(),
})
}
_ => None,
};
let recording_storage = match &egress_config {
Some(egress_config) => {
let cloudfront_config = RecordingCloudFrontConfig {
distribution_url: config
.document_storage_service_cloudfront_distribution_url
.as_ref()
.to_string(),
signer_public_key_id: config
.document_storage_service_cloudfront_signer_public_key_id
.as_ref()
.to_string(),
signer_private_key: config
.document_storage_service_cloudfront_signer_private_key
.as_ref()
.to_string(),
presigned_url_expiry_seconds: config::CALL_RECORDING_PRESIGNED_URL_EXPIRY_SECONDS,
};
Some(S3RecordingStorage::new(egress_config.bucket.clone(), cloudfront_config).await)
}
None => None,
};
let mut call_service_builder = CallServiceImpl::<_, _, _, _, _, _, AiCallSummarizer>::new(
call_repo,
livekit_rtc_client,
call_connection_service,
(*entity_access_service).clone(),
(*notification_ingress_service).clone(),
recording_storage,
config.livekit_server_url.as_ref(),
)
.with_summarizer(AiCallSummarizer::new(
ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
));
if let Some(secret) = internal_call_secret {
call_service_builder = call_service_builder.with_internal_call_secret(secret);
}
if let Some(config) = egress_config {
call_service_builder = call_service_builder.with_egress(config);
}
if let Some(base_url) = config::CallRingStatusBaseUrl::new() {
call_service_builder =
call_service_builder.with_ring_status_base_url(base_url.as_ref().to_owned());
}
// VoIP push is optional: enabled only when both env vars are present.
// APPLE_BUNDLE_ID: the app bundle ID (e.g. "com.macro.app.prod")
// SNS_APNS_VOIP_PLATFORM_ARN: SNS platform app ARN for APNS_VOIP
//
// Option<VoipPushServiceImpl<...>> is used as the type parameter so the
// type stays stable regardless of whether VoIP push is configured.
let voip_sender = if let (Some(bundle_id), Some(voip_arn)) =
(AppleBundleId::new(), SnsApnsVoipPlatformArn::new())
{
if voip_arn.is_empty() {
tracing::warn!("voip push disabled: SNS_APNS_VOIP_PLATFORM_ARN is set but empty");
None
} else {
let voip_repo =
notification::outbound::repository::DbNotificationRepository::new(db.clone());
let voip_mobile = notification::outbound::mobile::MobilePushAdapter {
push_service: aws_sdk_sns::Client::new(&aws_config),
apns_bundle_id: bundle_id.to_string(),
voip_bundle_id: Some(format!("{}.voip", bundle_id.as_ref())),
};
tracing::info!(
bundle_id = bundle_id.as_ref(),
voip_arn = voip_arn.as_ref(),
"voip push enabled"
);
Some(notification::domain::service::VoipPushServiceImpl::new(
voip_repo,
voip_mobile,
))
}
} else {
tracing::info!("voip push disabled: APPLE_BUNDLE_ID or SNS_APNS_VOIP_PLATFORM_ARN not set");
None
};
let call_service_builder = call_service_builder.with_voip_push_sender(voip_sender);
let call_root_poster = call::outbound::channel_threads::LateCallRootPoster::default();
let call_service_builder = call_service_builder
.with_voice_repo(PgVoiceRepo::new(db.clone()))
.with_event_broker(macro_event_broker.clone());
let flags = feature_flags::outbound::posthog::PostHogFeatureFlags::new(
config.posthog_host.value().unwrap_or(DEFAULT_POSTHOG_HOST),
config.posthog_api_key.as_ref().to_owned(),
// Flag evaluation is on the call-start path; fall back promptly.
Duration::from_millis(300),
)
.map_err(|error| anyhow::anyhow!("invalid feature flag configuration: {error}"))?;
let call_service_builder = call_service_builder.with_channel_threads(Arc::new(
call::outbound::channel_threads::FlaggedChannelThreads::new(
flags.clone(),
call_root_poster.clone(),
),
));
let call_service_builder = call_service_builder.with_programmatic_call_gate(
call::outbound::programmatic_calls::FlaggedProgrammaticCalls(flags),
);
let call_public_rate_limiter = RateLimitServiceImpl {
repo: RedisRateLimitAdapter {
redis: redis_client.clone(),
},
};
let call_service = Arc::new(call_service_builder.with_start_limiter(
call::inbound::axum_router::RateLimitedCallStarts(call_public_rate_limiter.clone()),
));
consumer_tracker.spawn({
let service = call_service.clone();
let cancellation_token = consumer_cancellation_token.clone();
async move {
cancellation_token
.run_until_cancelled(call::inbound::stale_call_sweeper::run_stale_call_sweeper(
service,
call::inbound::stale_call_sweeper::SWEEP_INTERVAL,
))
.await;
}
});
let call_state = CallRouterState::new(
call_service.clone(),
entity_access_service.clone(),
authorization_state.clone(),
);
let call_webhook_state = WebhookRouterState::new(call_service.clone());
let webhook_repository = webhook::outbound::PgRepository::new(db.clone());
let webhook_endpoint_scheme_policy = if matches!(env, Environment::Local) {
webhook::domain::models::WebhookEndpointSchemePolicy::HttpAndHttps
} else {
webhook::domain::models::WebhookEndpointSchemePolicy::HttpsOnly
};
let webhook_http_client =
webhook::outbound::ReqwestWebhookDeliveryClient::new_with_endpoint_scheme_policy(
webhook_endpoint_scheme_policy,
)
.context("failed to create webhook HTTP client")?;
let webhook_service =
webhook::domain::service::WebhookServiceImpl::new_with_endpoint_scheme_policy(
webhook_repository.clone(),
webhook_http_client.clone(),
webhook_endpoint_scheme_policy,
macro_event_broker.clone(),
);
let webhook_rate_limiter = RateLimitServiceImpl {
repo: RedisRateLimitAdapter {
redis: redis_client.clone(),
},
};
let webhook_state = webhook::inbound::axum_router::WebhookRouterState::new(
webhook_service,
webhook_rate_limiter,
authorization_state.clone(),
);
let (webhook_stream_sender, _) =
tokio::sync::broadcast::channel(webhook::domain::stream::WEBHOOK_STREAM_CHANNEL_CAPACITY);
let sse_stream_service = webhook::domain::stream::WebhookEventStreamServiceImpl::new(
webhook_stream_sender.clone(),
entity_access_service.clone(),
webhook_repository.clone(),
);
let sse_stream_state = webhook::inbound::stream_router::WebhookStreamRouterState::new(
sse_stream_service,
authorization_state.clone(),
);
consumer_tracker.spawn({
let brokers = config.kafka_brokers.as_ref().to_string();
let sender = webhook_stream_sender;
let cancellation_token = consumer_cancellation_token.clone();
async move {
loop {
let result = tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
result = webhook::inbound::kafka_stream_consumer::run_webhook_stream_consumer(
&brokers,
&sender,
) => result,
};
if cancellation_token.is_cancelled() {
break;
}
if let Err(error) = result {
tracing::error!(
error = ?error,
"webhook SSE Kafka consumer stopped"
);
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(1)) => {}
}
}
}
}
});
let webhook_ingestion_service =
webhook::domain::ingestion::WebhookEventIngestionServiceImpl::new(
entity_access_service.clone(),
webhook_repository,
webhook_event_queue.clone(),
);
let webhook_delivery_repository =
webhook::outbound::PgWebhookDeliveryRepository::new(db.clone());
let webhook_delivery_service = webhook::domain::delivery::WebhookEventDeliveryServiceImpl::new(
webhook_delivery_repository,
webhook_http_client,
);
let webhook_worker = webhook::inbound::worker::WebhookEventWorker::new(
webhook_event_queue,
webhook_delivery_service,
);
let webhook_worker_task = tokio::spawn(async move {
tracing::info!("starting webhook event worker");
webhook_worker.run().await;
});
tokio::spawn(async move {
match webhook_worker_task.await {
Ok(()) => tracing::error!("webhook event worker exited unexpectedly"),
Err(error) => {
tracing::error!(error = ?error, "webhook event worker exited unexpectedly");
}
}
});
let webhook_consumer_brokers = config.kafka_brokers.as_ref().to_string();
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
async move {
loop {
if cancellation_token.is_cancelled() {
break;
}
tracing::info!("starting webhook event consumer");
let result = webhook::inbound::kafka_consumer::run_webhook_event_consumer(
&webhook_consumer_brokers,
webhook_ingestion_service.clone(),
cancellation_token.cancelled(),
)
.await;
if cancellation_token.is_cancelled() {
break;
}
match result {
Ok(()) => tracing::error!("webhook event consumer exited unexpectedly"),
Err(error) => {
tracing::error!(error = ?error, "webhook event consumer exited unexpectedly");
}
}
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(5)) => {}
}
}
}
});
let (timeline_publisher, timeline_delivery) = crate::service::activity::TimelinePublisher::new(
conn_gateway_client.clone(),
messages::outbound::connection_gateway::ConnectionGatewayMessages(Arc::new(
conn_gateway_client.clone(),
)),
messages::outbound::entity_access_audience::EntityAccessMessageAudience(
(*entity_access_service).clone(),
),
);
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
async move {
tokio::select! {
_ = cancellation_token.cancelled() => {},
_ = timeline_delivery => {},
}
}
});
let activity_consumer_brokers = config.kafka_brokers.as_ref().to_string();
let editing_activity = Arc::new(
documents_hex::outbound::editing_activity::RedisEditingActivityStore::new(
redis_client.clone(),
),
);
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
let activity_repo = activity::outbound::pg_activity_repo::PgActivityRepo::new(db.clone());
let activity_realtime = activity::domain::announcements::ActivityAnnouncements::new(
activity::KafkaActivityRealtimePublisher::new(macro_event_broker.clone()),
crate::service::activity::EntityAccessActivityAudience::new(
entity_access_service.clone(),
),
);
async move {
let consumer = activity::inbound::kafka_consumer::ActivityConsumer::<
_,
crate::service::activity::ActivitySourceEvent,
_,
_,
>::new(
activity_repo,
move |event| {
let editing_activity = editing_activity.clone();
async move {
crate::service::activity::ingest(event, editing_activity.as_ref()).await
}
},
(activity_realtime, timeline_publisher),
);
loop {
if cancellation_token.is_cancelled() {
break;
}
tracing::info!("starting activity consumer");
let result = consumer
.run(&activity_consumer_brokers, cancellation_token.cancelled())
.await;
if cancellation_token.is_cancelled() {
break;
}
match result {
Ok(()) => tracing::error!("activity consumer exited unexpectedly"),
Err(error) => {
tracing::error!(error = ?error, "activity consumer exited unexpectedly");
}
}
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(5)) => {}
}
}
}
});
// Links archived calls to the CRM records of the people on them.
let crm_call_link_brokers = config.kafka_brokers.as_ref().to_string();
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
let consumer = crm::inbound::call_archived::CallArchivedConsumer::new(
crm::domain::call_links::CallRecordLinker::new(
call::domain::service::CallRecordQueryServiceImpl::new(PgCallRepo::new(
db.clone(),
)),
crm::outbound::call_link::PgCallCrmLinker::new(
db.clone(),
(*system_properties_service).clone(),
),
),
);
async move {
loop {
if cancellation_token.is_cancelled() {
break;
}
tracing::info!("starting CRM call-link consumer");
let result = consumer
.run(&crm_call_link_brokers, cancellation_token.cancelled())
.await;
if cancellation_token.is_cancelled() {
break;
}
match result {
Ok(()) => tracing::error!("CRM call-link consumer exited unexpectedly"),
Err(error) => {
tracing::error!(error = ?error, "CRM call-link consumer exited unexpectedly");
}
}
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(5)) => {}
}
}
}
});
let call_internal_state = InternalCallRouterState::new(call_service.clone());
// Create the SQS worker for delete document processing before config is moved.
#[cfg(feature = "delete_document_worker")]
let delete_document_worker = sqs_worker::SQSWorker::new(
aws_sdk_sqs::Client::new(&aws_config),
document_delete_queue.to_string(),
config.queue_max_messages,
config.queue_wait_time_seconds,
);
let sqs_client = Arc::new(sqs_client);
let conn_gateway_client = Arc::new(conn_gateway_client);
// MacroConfig reads the shared OPENAI_API_KEY from Doppler's APP_SECRETS_JSON
// or the local environment. Validate once before constructing consumers.
let openai_api_key = config.openai_api_key.as_ref().to_owned();
anyhow::ensure!(
!openai_api_key.trim().is_empty(),
"OpenAI API key is required for task dedup embeddings and dictation",
);
let cohere_api_key = config.cohere_api_key.as_ref().to_owned();
anyhow::ensure!(
!cohere_api_key.trim().is_empty(),
"Cohere API key is required for task dedup reranking",
);
let dictation_state = dictation::inbound::axum_router::DictationRouterState::new(
dictation::domain::DictationServiceImpl::new(
dictation::outbound::WhisperTranscriber::new(&config.openai_api_key)?,
dictation::outbound::SymphoniaRecordingInspector,
ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
),
RateLimitServiceImpl {
repo: RedisRateLimitAdapter {
redis: redis_client.clone(),
},
},
authorization_state.clone(),
);
let task_dedup_service = Arc::new(TaskDedupService::new(
TextEmbedding3Small::new(openai_api_key),
PgTaskVectorDb::new(db.clone()),
CohereReranker::new(cohere_api_key),
Arc::new(AgentDuplicateJudge::new(
ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
)),
Arc::new(ConnectionGatewayTaskDedupNotifier::new(
conn_gateway_client.clone(),
)),
Arc::new(PgTaskMatchRepo::new(db.clone())),
));
let channels_repo = PgChannelsRepo::new(db.clone());
// Built-in agents read the same committed-post stream as hosted and
// external agents, for channel and document posts alike, so the channel
// side effects no longer carry their own trigger queue.
let (bot_trigger_sender, bot_trigger_receiver) = tokio::sync::mpsc::unbounded_channel();
let channel_side_effects = ChannelSideEffectService::new(
PgChannelSideEffectContext::new(db.clone()),
ConnectionGatewayChannelRealtimePublisher::new(conn_gateway_client.clone()),
NotificationChannelSender::new(notification_ingress_service.clone()).with_completion(
NotificationReaderCompletion::new(
graphql_notification_reader.clone(),
Arc::new(notification::outbound::withdrawal::PgNotificationWithdrawal(db.clone())),
),
),
ContactsChannelDispatcher::new(contacts_ingress.clone()),
)
.with_macro_event_broker(macro_event_broker.clone());
let channels_service = Arc::new(
ChannelServiceImpl::with_dependencies(
channels_repo.clone(),
SpawnedChannelEventDispatcher::new(channel_side_effects.clone()),
PgChannelReferenceSharePermissions::new(db.clone(), entity_access_service.clone()),
)
.with_agent_direct_messages(Arc::new(channels::domain::agent_dm::AgentDmService::new(
channels_repo,
outbound::agent_dm_authorizer::BotServiceDmAuthorizer(bots_service.clone()),
SpawnedChannelEventDispatcher::new(channel_side_effects.clone()),
)))
.with_comment_parent_access(Arc::new(
channels::outbound::entity_access_comment_parents::EntityAccessCommentParents::new(
entity_access_service.clone(),
),
))
.with_picture_files(
channels::outbound::static_file_pictures::StaticFileChannelPictures::new(
static_file_service_client::StaticFileServiceClient::new(
config.internal_api_key.to_string(),
StaticFileServiceUrl::new()?.to_string(),
),
),
),
);
// One message implementation for channels and documents. Committed changes fan
// out to the broker, the local agent queue, and the parent's own delivery: channel
// messages keep their notifications, activity, and sharing side effects and send
// the common `message_update` payload; document discussions get the common
// payload and document comment notifications.
let message_realtime = messages::outbound::connection_gateway::ConnectionGatewayMessages(
conn_gateway_client.clone(),
);
let discussion_delivery = messages::domain::delivery::DiscussionDelivery::new(
messages::outbound::pg_discussion_context::PgDiscussionContext(db.clone())
.with_initiatives(
initiative::domain::lookup::InitiativeLookup::new(
initiative::outbound::PgInitiativeRepo::new(db.clone()),
),
properties_service.clone(),
)
.with_crm(crm::outbound::lookup::PgCrmParentReader::new(db.clone())),
messages::outbound::entity_access_audience::EntityAccessMessageAudience(
(*entity_access_service).clone(),
),
message_realtime.clone(),
messages::outbound::notification_sender::MessageNotificationSender(
notification_ingress_service.clone(),
),
)
.with_sharing(messages::outbound::pg_discussion_context::PgDiscussionContext(db.clone()));
let annotation_service = Arc::new(messages::domain::annotations::AnnotationService::new(
macro_db_client::annotations::repository::PgAnnotationRepository(db.clone()),
(*entity_access_service).clone(),
discussion_delivery.clone(),
));
let channel_delivery = channels::domain::message_delivery::ChannelMessageDelivery::new(
PgChannelsRepo::new(db.clone()),
SpawnedChannelEventDispatcher::new(channel_side_effects.clone()),
PgChannelReferenceSharePermissions::new(db.clone(), entity_access_service.clone()),
message_realtime,
channels::outbound::pg_agent_creations::PgAgentCreations::new(db.clone()),
);
let message_service = Arc::new(
messages::domain::service::MessageService::new(
messages::outbound::pg_message_repo::PgMessageRepository::new(db.clone())
.with_initiatives(initiative::domain::lookup::InitiativeLookup::new(
initiative::outbound::PgInitiativeRepo::new(db.clone()),
))
.with_crm(crm::outbound::lookup::PgCrmParentReader::new(db.clone())),
messages::domain::effects::MessageEffects::new(
messages::outbound::broker::BrokerMessagePublisher::new(macro_event_broker.clone()),
channel_bots::outbound::conversation::LocalBotPublisher::new(bot_trigger_sender),
messages::domain::delivery::ParentMessagePublisher::new(
channel_delivery,
discussion_delivery,
),
),
)
.with_activity(activity::outbound::pg_activity_repo::PgActivityRepo::new(
db.clone(),
))
.with_group_recipients(channels::domain::group_mentions::ChannelGroupRecipients(
PgChannelsRepo::new(db.clone()),
))
.with_mention_extractor(lexical_mention_extractor::LexicalMentionExtractor::new(
lexical_client.clone(),
))
.with_references(
messages::outbound::entity_access_audience::EntityAccessMessageReferences(
(*entity_access_service).clone(),
),
),
);
let message_commands: Arc<dyn messages::domain::api::MessageCommands> = message_service.clone();
let call_roots: Arc<dyn messages::domain::api::CallRootPoster> = message_service.clone();
if call_root_poster.set(call_roots).is_err() {
tracing::error!("the call root poster was set twice");
}
let guest_chat_service = Arc::new(
messages::domain::service::guest_chat::GuestChatService::new(
message_service.clone(),
call_service.clone(),
),
);
let messages_state = messages::inbound::axum_router::MessagesRouterState {
service: message_service.clone(),
access: entity_access_service.clone(),
authorization: authorization_state.clone(),
};
let teammate_dms_brokers = config.kafka_brokers.as_ref().to_string();
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
let channels = (*channels_service).clone();
async move {
loop {
if cancellation_token.is_cancelled() {
break;
}
tracing::info!("starting teammate DM consumer");
let result = channels::inbound::teammate_dms_consumer::run_teammate_dms_consumer(
&teammate_dms_brokers,
channels.clone(),
cancellation_token.cancelled(),
)
.await;
if cancellation_token.is_cancelled() {
break;
}
match result {
Ok(()) => tracing::error!("teammate DM consumer exited unexpectedly"),
Err(error) => {
tracing::error!(
error = ?error,
"teammate DM consumer exited unexpectedly"
);
}
}
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(5)) => {}
}
}
}
});
// Wire Macro AI to react to mentions with the classic in-channel chat
// reply. The router posts replies through the channel service we just
// built and runs the agent loop in-process with the channel-bot toolset:
// a channel has no composer to finish a chat-deferred user tool in, so
// calendar event creation executes directly and SendEmail is unavailable.
// Agent sessions belong to a different bot entirely
// (`bot_id::MACRO_NEW_BOT_ID`, served by the harness), so the two paths
// can never answer the same mention.
// This host holds no authentication-service key, so its counted usage is
// settled by that service's reconciliation sweep rather than requested
// after each completion.
let mut macro_agent_tool_context = ai_tools::build_tool_service_context_from_env(
db.clone(),
event_broker_tracker.clone(),
import_jobs.clone(),
config.enable_ai_usage_enforcement,
config.ai_pricing(),
ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
Some(Arc::new(
mcp_client::outbound::auth_service_github_tokens::AuthServiceGithubTokens::new(
authentication_service_client::AuthServiceClient::new(
config
.authentication_service_secret_key
.as_ref()
.to_string(),
macro_service_urls::AuthServiceUrl::new()?.to_string(),
),
),
)),
)
.await
.context("failed to build Macro agent tool context")?;
// Wire the agent's SendChannelMessage tool to this service's own
// side-effect pipeline so agent-posted messages share the exact instance
// used by the HTTP API, including the in-process bot trigger sender (the
// env builder wires an equivalent pipeline, but without bot triggers).
macro_agent_tool_context.channel_tool_context =
ai_tools::build_channel_tool_context_with_dispatcher(
db.clone(),
std::sync::Arc::new(SpawnedChannelEventDispatcher::new(
channel_side_effects.clone(),
)),
message_service.clone(),
);
let macro_agent_tools = ai_tools::tools_for(ai_tools::AiHost::ChannelBot);
let conversation_access = Arc::new(
channel_bots::outbound::conversation::EntityAccessConversation(
entity_access_service.clone(),
),
);
let admission = macro_agent_tool_context.admission.clone();
// Document AI edits over HTTP share the channel agent's admission.
let document_editing_worker = Arc::new(
documents_hex::outbound::editing_worker_client::ReqwestEditingWorkerClient::from_url(
AiEditingWorkerUrl::new()?.to_string(),
),
);
let document_ai_editing = Arc::new(documents_hex::domain::ai_editing::AiEditingService::new(
document_editing_worker.clone(),
admission.clone(),
ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
));
// The file-document routes read and write what the matching AI tools do.
let document_files = Arc::new(
documents_hex::outbound::s3_document_files::S3DocumentFiles::new(
db.clone(),
macro_aws_config::s3_client().await,
config.document_storage_bucket.to_string(),
),
);
let word_documents = Arc::new(
documents_hex::domain::word_document::WordDocumentService::new(
document_service.clone(),
document_editing_worker,
sync_service_client.clone(),
document_files.clone(),
config.document_permission_jwt.as_ref().to_string(),
),
);
let bot_trigger_router = channel_bots::inbound::BotTriggerRouter::new_with_admission(
message_service.clone(),
conversation_access.clone(),
Arc::new(channel_bots::outbound::AgentLoopResponder::new(
macro_agent_tool_context,
macro_agent_tools,
)),
Arc::new(
channel_bots::domain::trigger_detector::MentionOrInferredDetector::new(
message_service.clone(),
conversation_access,
Arc::new(channel_bots::outbound::FastModelTriggerClassifier::new(
ai_usage::pg_recorder_with_enforcement(
db.clone(),
config.enable_ai_usage_enforcement,
),
)),
)
.with_admission(admission.clone()),
),
Arc::new(channel_bots::outbound::PrimaryCalendarTimeZones::new(
Arc::new(calendar_events::domain::service::CalendarService::new(
calendar_events::outbound::pg::PgCalendarRepository::new(readonly_db.clone()),
)),
)),
Arc::new(channel_bots::outbound::LexicalCommentMarks::new(
(*lexical_client).clone(),
)),
admission,
);
bot_trigger_router.spawn(bot_trigger_receiver);
let channel_bot_webhook_state =
bots::inbound::channel_webhook_router::ChannelBotWebhookRouterState::new(
bots_service.clone(),
message_commands.clone(),
(*entity_access_service).clone(),
authorization_state.clone(),
);
let slack_limits = slack_integration::domain::models::ImportLimits::default();
let slack_enabled = config.slack_import_enabled;
let slack_service = api::context::SlackService::new(
slack_integration::outbound::pg_slack_import_repo::PgSlackImportRepo::new(
db.clone(),
slack_limits,
),
slack_integration::outbound::s3_storage::S3ImportStorage::new(
macro_aws_config::s3_client().await,
config.upload_staging_bucket.as_ref().to_owned(),
slack_limits,
)
.map_err(|_| anyhow::anyhow!("invalid Slack import storage configuration"))?,
slack_integration::outbound::import_ledger::CanonicalImportLedger::new(
import::outbound::pg_import_repo::PgImportRepo::new(db.clone()),
),
slack_integration::outbound::gateway_notifier::GatewayImportNotifier::new(
conn_gateway_client.clone(),
),
api::context::SlackAdminAuthorizer(
entity_access_service.clone(),
entity_access::outbound::PgAccessRepository::new(db.clone()),
),
Box::new(move |_| slack_enabled),
slack_limits,
)?;
let slack_state = slack_integration::inbound::axum_router::SlackRouterState {
service: Arc::new(slack_service),
entity_access_service: entity_access_service.clone(),
authorization_state: authorization_state.clone(),
};
let external_chat_state = crate::external_chat::build(crate::external_chat::Dependencies {
redis: redis_client.clone(),
static_files: static_file_service_client::StaticFileServiceClient::new(
config.internal_api_key.to_string(),
StaticFileServiceUrl::new()?.to_string(),
),
pool: db.clone(),
access: entity_access_service.clone(),
authorization: authorization_state.clone(),
notifications: notification_ingress_service.clone(),
connection_gateway: conn_gateway_client.clone(),
tracker: consumer_tracker.clone(),
cancellation: consumer_cancellation_token.clone(),
});
// Held by value here and behind an `Arc` in the router state: the impl is a
// pool handle, so cloning is cheap and `SoupImpl` needs an owned service.
// Additional connections for guards spanning email I/O. HTTP requests and
// dispatch share this budget, independently of the main data pool.
let followup_lock_capacity = match config.environment {
Environment::Production => 32,
Environment::Develop => 16,
Environment::Local => 8,
};
let email_followups = reminders::domain::email_followup::service::EmailFollowupService::new(
PgRemindersRepo::with_followup_lock_capacity(db.clone(), followup_lock_capacity),
email_service.clone(),
);
let reminders_service =
reminders::domain::email_followup::reminder_service::EmailRemindersService::new(
email_followups.clone(),
)
.with_entity_access((*entity_access_service).clone());
let document_creator = documents_hex::domain::create::DocumentCreator::new(
document_service.clone(),
markdown_initializer,
documents_hex::outbound::document_bytes_upload::ReqwestDocumentBytesUploader::default(),
documents_hex::outbound::mention_tracker::LexicalCommsMentionTracker::new(
db.clone(),
lexical_client.clone(),
),
);
// Forms' ids are their surfaces' ids, so the public surface API asks the
// forms domain which ids are taken.
let collab_surface_service = Arc::new(
collab_surface::outbound::pg_collab_surface_service(
db.clone(),
lexical_client.as_ref().clone(),
sync_service_client.as_ref().clone(),
config.document_permission_jwt.as_ref().to_string(),
)
.with_form_ids(Arc::new(
forms::outbound::collaborative_layout::RepositoryFormIds::new(Arc::new(
forms::outbound::pg_forms_repo::PgFormsRepo::new(db.clone()),
)),
)),
);
let initiative_service = Arc::new(
InitiativeServiceImpl::new(
PgInitiativeRepo::new(db.clone()),
initiative_description::InitiativeDescriptionSurfacesAdapter::new(
collab_surface_service.clone(),
),
Arc::new(initiative::outbound::resources::ProjectResources::new(
properties_service.clone(),
system_properties_service.clone(),
entity_access_service.clone(),
)),
)
.with_event_publisher(Arc::new(
initiative::outbound::event_publisher::BrokerInitiativeEventPublisher::new(
macro_event_broker.clone(),
),
)),
);
// Shared by the databases router and the unified entity-mutation router.
let databases_service = Arc::new(databases::wiring::build_service(
db.clone(),
entity_access_service.clone(),
databases::outbound::gateway_event_publisher::GatewayTableEventPublisher::new(
conn_gateway_client.as_ref().clone(),
),
macro_event_broker.clone(),
));
let pipeline_service = Arc::new(crm::domain::pipelines::PipelineServiceImpl::new(
crm::outbound::pipelines::PgPipelineRepo::new(
db.clone(),
databases::outbound::pg_cell_store::PgCellStore::new(
db.clone(),
properties::outbound::properties_pg_repo::PropertiesPgRepo::new(db.clone()),
),
),
databases_service.clone(),
entity_access_service.clone(),
crm::outbound::stage_definitions::PropertiesStageDefinitionStore::new(
properties_service.clone(),
),
));
let database_webhooks_service = Arc::new(database_webhooks::wiring::build_service(
db.clone(),
databases_service.clone(),
entity_access_service.clone(),
));
let forms_service = Arc::new(forms::wiring::build_service(
db.clone(),
databases_service.clone(),
entity_access_service.clone(),
forms::outbound::gateway_event_publisher::GatewayFormEventPublisher::new(
conn_gateway_client.as_ref().clone(),
),
macro_event_broker.clone(),
collab_surface_service.clone(),
static_file_service_client::StaticFileServiceClient::new(
config.internal_api_key.to_string(),
StaticFileServiceUrl::new()?.to_string(),
),
));
// Individual initiative and agent-session reads preserve read-after-write
// consistency when a newly created entity opens immediately, as does
// realtime patch hydration, which runs right after the write it announces.
// Lists retain the replica reader. Reuse Soup hydration so detail and
// mutation metadata include viewer history.
let primary_entity_soup = Arc::new(
SoupImpl::new(
PgSoupRepo::new(readonly_pool::ReadOnlyPool(db.clone())),
frecency_service.clone(),
ReadonlyEmailPreviewAdapter(email_service.clone()),
ChannelListServiceImpl::new(
PgChannelsRepo::new(db.clone()),
PgChannelsRepo::new(db.clone()),
frecency_storage.clone(),
)
.with_agent_dm_profiles(agent_dm_profiles),
call::domain::service::CallRecordQueryServiceImpl::new(PgCallRepo::new(db.clone())),
crm_service.clone(),
GithubPullRequestServiceImpl::new(
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
PgGithubPullRequestRepo::new(db.clone()),
),
)
.with_agent_branches(agent_changes::outbound::postgres::PgChangesetRepo::new(
db.clone(),
)),
);
// SQL predicates and follow-up reads use the primary, matching the catalog
// versions and writes; replica lag must not select stale rows for an edit.
let sql_service = databases_sql::DatabasesSql::new(
databases_service.clone(),
entity_access_service.clone(),
primary_entity_soup.clone(),
Arc::new(contacts::domain::service::ContactsDomainService {
repository: contacts::outbound::repository::DbContactsRepository::new(db.clone()),
notifier: None::<contacts::outbound::gateway::ConnectionGatewayNotifier>,
}),
);
let favorites_service = Arc::new(FavoritesServiceImpl::new(PgFavoritesRepo::new(db.clone())));
// Keep the replica-backed Soup reader alongside the primary-backed email
// writer in SoupRouterState. REST and GraphQL lists share this reader;
// only email mutations and their reply loader use the writer service, so
// normal list traffic never switches to the primary.
let soup_service = Arc::new(
SoupImpl::new(
PgSoupRepo::new(readonly_pool::ReadOnlyPool(readonly_db.clone())),
frecency_service,
readonly_email_service.clone(),
ChannelListServiceImpl::new(
PgChannelsRepo::new(readonly_db.clone()),
PgChannelsRepo::new(readonly_db.clone()),
frecency_storage.clone(),
)
.with_agent_dm_profiles(Arc::new(
outbound::agent_dm_authorizer::AgentDmProfileReader::new(
PgChannelsRepo::new(readonly_db.clone()),
PgBotsRepo::new(readonly_db.clone()),
),
)),
call::domain::service::CallRecordQueryServiceImpl::new(PgCallRepo::new(
readonly_db.clone(),
)),
crm_service.clone(),
GithubPullRequestServiceImpl::new(
ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(readonly_db.clone())),
PgGithubPullRequestRepo::new(readonly_db.clone()),
),
)
.with_favorites(favorites_service.clone())
.with_agent_branches(agent_changes::outbound::postgres::PgChangesetRepo::new(
readonly_db.clone(),
)),
);
let websocket_notification_consumer_service =
Arc::new(WebSocketNotificationConsumerService::new(
NotificationTopicConsumer::<model_notifications::NotifEvent>::from_env(
config.kafka_brokers.as_ref(),
)
.map_err(|error| {
anyhow::anyhow!("failed to create WebSocket notification topic consumer: {error:?}")
})?,
));
consumer_tracker.spawn({
let service = Arc::clone(&websocket_notification_consumer_service);
let cancellation_token = consumer_cancellation_token.clone();
async move {
loop {
let result = tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
result = service.run() => result,
};
if cancellation_token.is_cancelled() {
break;
}
let _ = result.inspect_err(|error| {
tracing::error!(
error = ?error,
"WebSocket notification consumer stopped"
);
});
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(1)) => {}
}
}
}
});
let activity_realtime_service = Arc::new(activity::ActivityRealtimeConsumerService::new(
activity::ActivityTopicConsumer::from_env(config.kafka_brokers.as_ref()).map_err(
|error| anyhow::anyhow!("failed to create realtime activity topic consumer: {error:?}"),
)?,
));
consumer_tracker.spawn({
let service = Arc::clone(&activity_realtime_service);
let cancellation_token = consumer_cancellation_token.clone();
async move {
loop {
let result = tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
result = service.run() => result,
};
if cancellation_token.is_cancelled() {
break;
}
let _ = result.inspect_err(|error| {
tracing::error!(
error = ?error,
"realtime activity subscription consumer stopped"
);
});
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(1)) => {}
}
}
}
});
let soup_realtime_service = Arc::new(SoupRealtimeConsumerService::new(
SoupTopicConsumer::from_env(config.kafka_brokers.as_ref()).map_err(|error| {
anyhow::anyhow!("failed to create realtime Soup topic consumer: {error:?}")
})?,
));
consumer_tracker.spawn({
let soup_realtime_service = Arc::clone(&soup_realtime_service);
let cancellation_token = consumer_cancellation_token.clone();
async move {
loop {
let result = tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
result = soup_realtime_service.run() => result,
};
if cancellation_token.is_cancelled() {
break;
}
let _ = result.inspect_err(|error| {
tracing::error!(
error = ?error,
"realtime Soup subscription consumer stopped"
);
});
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(1)) => {}
}
}
}
});
// Reads the harness' agent session log stream through a consumer group of
// this process' own, and fans each run out to GraphQL log subscribers.
let agent_session_log_realtime = Arc::new(AgentSessionLogConsumerService::new(
RedisLogStreamConsumer::connect(redis_client.clone())
.await
.map_err(|error| {
anyhow::anyhow!("failed to create agent session log stream consumer: {error:?}")
})?,
));
consumer_tracker.spawn({
let service = Arc::clone(&agent_session_log_realtime);
let cancellation_token = consumer_cancellation_token.clone();
async move {
loop {
let result = tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
result = service.run() => result,
};
if cancellation_token.is_cancelled() {
break;
}
let _ = result.inspect_err(|error| {
tracing::error!(
error = ?error,
"agent session log subscription consumer stopped"
);
});
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(Duration::from_secs(1)) => {}
}
}
// Nothing reads this process' group once it stops.
let _ = service.consumer().close().await.inspect_err(|error| {
tracing::warn!(
error = ?error,
"failed to close the agent session log stream consumer group"
);
});
}
});
consumer_tracker.spawn({
let session_repo = agent_session::outbound::postgres::PgAgentSessionRepo::new(
db.clone(),
owned_entity_registrar.clone(),
);
let brokers = config.kafka_brokers.as_ref().to_string();
let entity_access_service = entity_access_service.as_ref().clone();
let macro_event_broker = macro_event_broker.clone();
let cancellation_token = consumer_cancellation_token.clone();
async move {
let mut consecutive_failures = 0_u32;
loop {
if cancellation_token.is_cancelled() {
break;
}
let fanout_service = SoupRealtimeServiceImpl::new(
EntityAccessExpander::new(entity_access_service.clone()),
KafkaSoupRealtimePublisher::new(macro_event_broker.clone()),
);
tracing::info!("starting realtime Soup entity consumer");
let result = fanout_service
.run_entity_update_consumer(
&brokers,
&soup_realtime::outbound::agent_sessions::AgentSessionPullRequestLookup(
session_repo.clone(),
),
cancellation_token.cancelled(),
)
.await;
if cancellation_token.is_cancelled() {
break;
}
let restart_delay = match result {
Ok(()) => {
consecutive_failures = 0;
tracing::error!("realtime Soup entity consumer exited unexpectedly");
soup_consumer_restart_delay(1)
}
Err(error) => {
consecutive_failures = consecutive_failures.saturating_add(1);
let restart_delay = soup_consumer_restart_delay(consecutive_failures);
if consecutive_failures >= SOUP_CONSUMER_RESTART_ALERT_THRESHOLD {
tracing::error!(
error = ?error,
consecutive_failures,
restart_delay_secs = restart_delay.as_secs(),
"realtime Soup entity consumer repeatedly failed"
);
} else {
tracing::warn!(
error = ?error,
consecutive_failures,
restart_delay_secs = restart_delay.as_secs(),
"realtime Soup entity consumer failed; scheduling restart"
);
}
restart_delay
}
};
tokio::select! {
biased;
_ = cancellation_token.cancelled() => break,
_ = tokio::time::sleep(restart_delay) => {}
}
}
}
});
let favorites_mutation_service = Arc::new(FavoritesMutationServiceImpl::new(
favorites_service.clone(),
entity_access_service.clone(),
));
let account_manager_service = Arc::new(AccountManagerServiceImpl::new(
PgAccountManagerRepo::new(db.clone()),
DmAccountManagerDelivery::new(
channels_service.clone(),
message_commands.clone(),
entity_access_service.clone(),
macro_service_urls::AppServiceUrl::new()?,
),
));
let user_api_key_service = Arc::new(UserApiKeyServiceImpl::new(PgUserApiKeysRepo::new(
db.clone(),
)));
// The GraphQL own-calendar feed reads the primary, like the REST calendar
// routes: a `refresh_calendar` poke goes out as the write commits, and the
// delta it triggers would find nothing on a lagging replica, leaving the
// change unseen until some later poke. Range reads share the pool so a
// page cannot overwrite what a delta already applied with older rows.
let calendar_read_service = Arc::new(calendar_events::domain::service::CalendarService::new(
calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
));
let graphql_calendar_context = graphql_calendar::CalendarGraphqlContext::new(
calendar_read_service.clone(),
Arc::new(
calendar_events::domain::changes::CalendarChangeService::new(
calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
),
),
);
// Team policy reads use the primary so a sharing downgrade cannot be
// served from a lagging replica.
let calendar_state = CalendarRouterState::new(
Arc::new(
calendar_events::domain::service::CalendarService::new(
calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
)
.with_team_sharing_enabled(config.calendar_team_sharing_enabled),
),
authorization_state.clone(),
);
// Join requests write, so they use the primary like the team policy reads.
let calendar_join_request_state =
calendar_events::inbound::join_request_router::CalendarJoinRequestRouterState::new(
Arc::new(
calendar_events::domain::join_requests::CalendarJoinRequestServiceImpl::new(
calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
calendar_events::outbound::notification_notifier::NotificationCalendarJoinRequestNotifier::new(
(*notification_ingress_service).clone(),
),
crate::outbound::calendar_refresh::ConnectionGatewayCalendarRefresh::new(
(*conn_gateway_client).clone(),
db.clone(),
event_broker_tracker.clone(),
),
),
),
authorization_state.clone(),
);
// Calendar writes belong to calendar_service; each GraphQL mutation then
// answers from the primary so it reads the state its write committed.
let graphql_calendar_mutation_context = graphql_calendar::CalendarGraphqlMutationContext::new(
Arc::new(
calendar_events::outbound::calendar_service_mutations::CalendarServiceMutations::new(
macro_service_urls::CalendarServiceUrl::new()
.context("calendar service url")?
.to_string(),
config.internal_api_key.to_string(),
),
),
Arc::new(
calendar_events::domain::changes::CalendarChangeService::new(
calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
),
),
);
// Reminder dispatch. An EventBridge rule drops a sweep tick on this queue
// every minute; the sweep fans one message out per due firing, onto the
// same queue, and every task in the pool delivers them in parallel.
let reminder_dispatch_worker = {
let queue = SqsDispatchQueue::new(
aws_sdk_sqs::Client::new(&aws_config),
reminder_dispatch_queue.to_string(),
);
let dispatch_service = ReminderDispatchService::new(
PgRemindersRepo::new(db.clone()),
NotificationReminderNotifier::new((*notification_ingress_service).clone()),
queue.clone(),
);
DispatchWorker::new(
reminders::domain::email_followup::dispatch::EmailReminderDispatch::new(
dispatch_service,
email_followups.clone(),
),
queue,
)
};
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
async move {
tracing::info!("starting reminder dispatch worker");
reminder_dispatch_worker.run(cancellation_token).await;
tracing::info!("reminder dispatch worker stopped");
}
});
// Calendar event reminder dispatch: same sweep/deliver shape as reminders,
// on its own queue. Behind a master switch — when off, the worker drains
// the minutely tick so the queue neither backs up nor dead-letters.
let calendar_reminder_dispatch_worker = {
let queue = SqsCalendarDispatchQueue::new(
aws_sdk_sqs::Client::new(&aws_config),
calendar_reminder_dispatch_queue.to_string(),
);
let dispatch_service = CalendarReminderDispatchService::new(
calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
NotificationCalendarReminderNotifier::new((*notification_ingress_service).clone()),
queue.clone(),
);
CalendarReminderDispatchWorker::new(dispatch_service, queue)
};
consumer_tracker.spawn({
let cancellation_token = consumer_cancellation_token.clone();
let enabled = config.calendar_reminder_dispatch_enabled;
async move {
if enabled {
tracing::info!("starting calendar reminder dispatch worker");
calendar_reminder_dispatch_worker
.run(cancellation_token)
.await;
tracing::info!("calendar reminder dispatch worker stopped");
} else {
tracing::info!("calendar reminder dispatch disabled; draining its queue");
calendar_reminder_dispatch_worker
.drain(cancellation_token)
.await;
}
}
});
let redis_sha_client = Arc::new(Redis::new(redis_client));
let document_purger = Arc::new(documents_hex::domain::purge::DocumentPurger::new(
documents_hex::outbound::document_purge::LegacyDocumentPurgeRepository::new(db.clone()),
documents_hex::outbound::document_purge::SqsDocumentPurgeQueue::new(sqs_client.clone()),
documents_hex::outbound::document_purge::RedisDocxPartReferences::new(
redis_sha_client.clone(),
),
macro_event_broker.clone(),
));
let owned_purge_state = DssOwnedPurgeState::new(
document_purger.clone(),
Arc::new(
chat::domain::service::ChatServiceImpl::new_without_tools(
chat::outbound::postgres::PgChatRepo::new(
db.clone(),
owned_entity_registrar.clone(),
),
entity_access_management_service.clone(),
)
.with_event_broker(macro_event_broker.clone()),
),
project_service.clone(),
);
let graphql_entity_mutation_service =
Arc::new(service::entity_mutation::DssEntityMutationService::new(
document_service.clone(),
chat_mutation_service,
channels_service.clone(),
call_service.clone(),
Arc::new(email_service.clone()),
project_service.clone(),
databases_service.clone(),
forms_service.clone(),
entity_access_service.clone(),
Arc::new(outbound::entity_mutation::DssEntityLifecycleAdapter::new(
db.clone(),
redis_sha_client.clone(),
sqs_client.clone(),
macro_event_broker.clone(),
)),
));
// Routine writes still use the scheduled-action service. Read from the
// primary pool here so the GraphQL list cannot restore stale state after
// a REST write.
let scheduled_action_read_service = Arc::new(ScheduledActionReadServiceImpl::new(
Arc::new(PgScheduledActionRepo::new(
db.clone(),
owned_entity_registrar.clone(),
)),
entity_access_service.clone(),
));
// Attention feeds (Home's work feed and the notifications inbox) share
// one feed layer and these adapters: Soup
// candidates over the replica, notification acknowledgement on the
// primary, and live updates recomputed from the viewer's notification,
// activity and Soup streams. Done publishes a viewer-addressed Soup patch
// so the viewer's other sessions recompute too: GraphQL notification
// writes publish no realtime update.
let feed_triggers: Arc<dyn attention_feed::domain::ports::FeedTriggers> = Arc::new(
attention_feed::outbound::triggers::RealtimeFeedTriggers::new(
websocket_notification_consumer_service.clone(),
activity_realtime_service.clone(),
soup_realtime_service.clone(),
),
);
let feed_viewers: Arc<dyn attention_feed::inbound::viewers::FeedViewerResolver> = Arc::new(
attention_feed::inbound::viewers::EntityAccessFeedViewers(entity_access_service.clone()),
);
// Reads the primary: a client refetches right after the change it heard about.
let graphql_registered_work_context = complete_graph::RegisteredWorkGraphqlContext::new(
agent_session::domain::work_registration::WorkRegistrationService::new(
agent_session::outbound::postgres::PgAgentSessionRepo::new(
db.clone(),
owned_entity_registrar.clone(),
),
Arc::new(
agent_session::domain::audience::EntityAccessSessionView::new(
entity_access_service.as_ref().clone(),
),
),
agent_session::domain::work_registration::NoWorkRegistrationSignal,
),
soup_realtime_service.clone(),
);
let graphql_work_feed_context = complete_graph::WorkFeedGraphqlContext::new(
work_feed::domain::service::WorkFeedServiceImpl::new(
attention_feed::outbound::soup::SoupCandidateSource::new(
soup_service.clone(),
Arc::new(email_service.clone()),
),
attention_feed::outbound::notifications::ReaderFeedNotifications::new(
graphql_notification_reader.clone(),
),
attention_feed::outbound::mail::EmailFeedMail::new(Arc::new(email_service.clone())),
attention_feed::outbound::signals::SoupRealtimeFeedSignals::new(
KafkaSoupRealtimePublisher::new(macro_event_broker.clone()),
),
),
feed_triggers.clone(),
feed_viewers.clone(),
);
let graphql_notification_inbox_context = complete_graph::NotificationInboxGraphqlContext::new(
notification_inbox::domain::service::NotificationInboxServiceImpl::new(
attention_feed::outbound::soup::SoupCandidateSource::new(
soup_service.clone(),
Arc::new(email_service.clone()),
),
attention_feed::outbound::notifications::ReaderFeedNotifications::new(
graphql_notification_reader.clone(),
),
attention_feed::outbound::mail::EmailFeedMail::new(Arc::new(email_service.clone())),
attention_feed::outbound::signals::SoupRealtimeFeedSignals::new(
KafkaSoupRealtimePublisher::new(macro_event_broker.clone()),
),
),
feed_triggers,
feed_viewers,
);
let sync_sessions =
sync_router::session::SyncSessionFactory::new(SyncServiceUrl::new()?.as_ref().parse()?)?;
let api_context = ApiContext {
sync_sessions,
dictation_state,
graphql_work_feed_context,
graphql_registered_work_context,
graphql_notification_inbox_context,
contacts_ingress: contacts_ingress.clone(),
soup_router_state: SoupRouterState::from_arc(
soup_service.clone(),
email_service.clone(),
entity_access_service.clone(),
authorization_state.clone(),
)
.with_favorites_reader(Arc::new(
service::soup_favorites_reader::DssSoupFavoritesReader(favorites_service.clone()),
)),
favorites_state: FavoritesRouterState::new(
favorites_service.clone(),
entity_access_service.clone(),
authorization_state.clone(),
),
favorites_service,
favorites_mutation_service,
channel_labels_state: ChannelLabelsRouterState::new(
Arc::new(ChannelLabelsServiceImpl::new(PgChannelLabelsRepo::new(
db.clone(),
))),
entity_access_service.clone(),
authorization_state.clone(),
),
account_manager_state: AccountManagerRouterState::new(
account_manager_service,
authorization_state.clone(),
),
user_api_key_state: UserApiKeyRouterState::new(
user_api_key_service,
authorization_state.clone(),
),
slack_state,
external_chat_state,
reminders_state: RemindersRouterState::new(
Arc::new(reminders_service),
entity_access_service.clone(),
authorization_state.clone(),
),
access_requests_state: access_requests::inbound::axum_router::AccessRequestsRouterState {
service: access_requests_service,
authorization_state: authorization_state.clone(),
},
graphql_initiative_entity_loader: graphql_initiative::InitiativeEntityLoader(
graphql_soup::soup_item_loader(
primary_entity_soup.clone(),
Arc::new(email_service.clone()),
entity_access_service.as_ref().clone(),
),
),
graphql_agent_session_entity_loader: graphql_soup::AgentSessionEntityLoader::new(
primary_entity_soup.clone(),
Arc::new(email_service.clone()),
entity_access_service.as_ref().clone(),
),
graphql_database_rows_context: graphql_databases::DatabaseRowsGraphqlContext::new(
databases_sql::view_rows::DatabaseViewRows::new(
databases_service.clone(),
databases::outbound::pg_view_rows::PgViewRows::new(db.clone()),
),
entity_access_service.clone(),
graphql_soup::soup_item_loader(
primary_entity_soup.clone(),
Arc::new(email_service.clone()),
entity_access_service.as_ref().clone(),
),
),
graphql_primary_soup_item_loader: graphql_soup::PrimarySoupItemLoader::new(
primary_entity_soup,
Arc::new(email_service.clone()),
entity_access_service.as_ref().clone(),
),
// Ordinary single-entity GraphQL reads use the replica-backed Soup
// and email readers. Subscription hydration, `soupEntity`, and
// mutation replies above read the primary.
graphql_soup_item_loader: graphql_soup::soup_item_loader_with_team_access(
soup_service.clone(),
Arc::new(readonly_email_service),
entity_access_service.as_ref().clone(),
),
email_focus_reader: Arc::new(email::domain::focus::FocusQueries::new(
email::outbound::FocusPgRepository(readonly_db.clone()),
)),
graphql_crm_context: graphql_crm::CrmGraphqlContext::new(pipeline_service.clone()),
graphql_initiative_context: graphql_initiative::InitiativeGraphqlContext::new(
initiative_service.clone(),
entity_access_service.clone(),
),
graphql_scheduled_action_context: ScheduledActionGraphqlContext::new(
scheduled_action_read_service,
),
graphql_calendar_context,
graphql_calendar_mutation_context,
initiative_state: InitiativeRouterState::new(
initiative_service,
entity_access_service.clone(),
authorization_state.clone(),
),
sql_state: databases_sql::inbound::axum_router::SqlRouterState::new(
sql_service,
authorization_state.clone(),
),
databases_state: databases::inbound::axum_router::DatabasesRouterState::new(
databases_service,
entity_access_service.clone(),
authorization_state.clone(),
),
database_webhooks_state:
database_webhooks::inbound::axum_router::DatabaseWebhooksRouterState::new(
database_webhooks_service,
entity_access_service.clone(),
authorization_state.clone(),
),
forms_state: forms::inbound::axum_router::FormsRouterState::new(
forms_service,
entity_access_service.clone(),
authorization_state.clone(),
),
database_starter_state: databases::inbound::starter_router::DatabaseStarterRouterState::new(
Arc::new(databases::domain::starter::DatabaseStarterServiceImpl::new(
databases::outbound::pg_starter::PgDatabaseStarterRepo::new(
db.clone(),
properties::outbound::properties_pg_repo::PropertiesPgRepo::new(db.clone()),
),
macro_event_broker.clone(),
)),
authorization_state.clone(),
),
collab_surface_state: CollabSurfaceRouterState::new(
collab_surface_service,
entity_access_service.clone(),
authorization_state.clone(),
),
graphql_soup_schema: complete_graph::build_schema_from_arcs(
soup_service,
soup_realtime_service,
websocket_notification_consumer_service,
activity_realtime_service,
),
agent_session_log_subscriptions: complete_graph::agent_session_log_subscriptions(
agent_session_log_realtime,
),
graphql_notification_reader,
// GraphQL reads the activity log through the readonly pool; the
// Kafka consumer's writer-pool repo above is separate on purpose.
activity_reader: complete_graph::ActivityPortReader::new(Arc::new(
initiative::domain::personal_activity::ProjectVisibleActivityReads::new(
activity::outbound::pg_activity_repo::PgActivityRepo::new(readonly_db.clone()),
entity_access_service.clone(),
),
)),
graphql_entity_mutation_service,
github_sync_service: Arc::new(github_sync_service_impl),
github_pull_request_index_state,
github_pull_request_state,
github_pull_request_changes_state,
foreign_entity_state,
db: db.clone(),
readonly_db: readonly_pool::ReadOnlyPool(readonly_db.clone()),
redis_client: redis_sha_client,
s3_client: s3,
dynamodb_client: Arc::new(dynamodb_client),
dynamo_db,
macro_event_broker: macro_event_broker.clone(),
sqs_client: sqs_client.clone(),
document_purger,
notification_ingress_service: notification_ingress_service.clone(),
conn_gateway_client: conn_gateway_client.clone(),
sync_service_client: sync_service_client.clone(),
system_properties_service: system_properties_service.clone(),
properties_service: properties_service.clone(),
opensearch_client: Arc::new(opensearch_client),
authorization_state: authorization_state.clone(),
jwt_validation_args,
dss_auth_key,
// Shared frecency storage and legacy channel list routes.
frecency_storage,
channel_list_state,
entity_access_service: entity_access_service.clone(),
calendar_state,
calendar_join_request_state,
projects_state: ProjectRouterState {
service: project_service,
access_service: entity_access_service.clone(),
authorization_state: authorization_state.clone(),
non_user_owners,
},
documents_state: DocumentRouterState {
service: document_service,
access_service: entity_access_service.clone(),
authorization_state: authorization_state.clone(),
pool: db.clone(),
task_dedup_service,
lexical_client: lexical_client.clone(),
creator: document_creator,
ai_editing: document_ai_editing,
presentations: Arc::new(
documents_hex::domain::presentation::PresentationService::new(
document_files.clone(),
),
),
word_documents,
designs: Arc::new(documents_hex::domain::design::DesignService::new(
document_files.clone(),
)),
photoshop_documents: Arc::new(documents_hex::domain::photoshop::PhotoshopService::new(
document_files.clone(),
)),
illustrator_documents: Arc::new(
documents_hex::domain::illustrator::IllustratorService::new(document_files),
),
document_permission_jwt_secret: config.document_permission_jwt.as_ref().to_string(),
non_user_owners,
},
config: Arc::new(config),
channel_service: channels_service.clone(),
channels_state: ChannelsRouterState::from_arc(
channels_service,
(*entity_access_service).clone(),
authorization_state.clone(),
),
messages_state,
guest_chat_service,
annotation_service,
bots_state: bots::inbound::axum_router::BotsRouterState::new(
bots_service.clone(),
(*entity_access_service).clone(),
authorization_state.clone(),
),
harnesses_state: harnesses::inbound::axum_router::HarnessesRouterState::new(
harnesses_service,
authorization_state.clone(),
),
channel_bot_webhook_state,
call_state,
call_webhook_state,
call_public_rate_limiter,
webhook_state,
sse_stream_state,
call_internal_state,
cal_webhook_state,
entity_access_management_service,
pipeline_state: crm::inbound::pipelines::PipelineRouterState {
service: pipeline_service,
access: entity_access_service.clone(),
authorization: authorization_state.clone(),
},
crm_state: crm::inbound::axum_router::CrmRouterState {
service: Arc::new(crm_service),
stage_service: Arc::new(crm::domain::stages::CrmStageServiceImpl::new(
crm::outbound::companies_repo::CompaniesRepositoryImpl::new(db.clone()),
crm::outbound::stage_definitions::PropertiesStageDefinitionStore::new(
properties_service.clone(),
),
)),
entity_access_service: entity_access_service.clone(),
authorization_state: authorization_state.clone(),
},
owned_purge_state,
};
#[cfg(feature = "delete_document_worker")]
{
let editing_worker_client = Arc::new(
documents_hex::outbound::editing_worker_client::ReqwestEditingWorkerClient::from_url(
AiEditingWorkerUrl::new()?.to_string(),
)
.with_internal_auth_key(Some(api_context.config.internal_api_key.to_string())),
);
// Spawn the delete document worker.
let delete_worker_ctx = service::delete_document_worker::DeleteDocumentWorkerContext {
worker: Arc::new(delete_document_worker),
db: db.clone(),
s3_client: api_context.s3_client.clone(),
redis_client: api_context.redis_client.clone(),
sync_service_client: api_context.sync_service_client.clone(),
editing_worker_client,
properties_service: api_context.properties_service.clone(),
};
tokio::spawn(async move {
service::delete_document_worker::run_worker(delete_worker_ctx).await;
});
}
let server_result = api::setup_and_serve(api_context).await;
tracing::info!("stopping event consumers");
consumer_cancellation_token.cancel();
consumer_tracker.close();
consumer_tracker.wait().await;
tracing::info!("event consumers stopped");
// Running imports stop at their next checkpoint and hand their runs over.
import_jobs.hand_over().await;
tracing::info!("waiting for event broker publishes to drain");
event_broker_tracker.close();
match tokio::time::timeout(EVENT_BROKER_DRAIN_TIMEOUT, event_broker_tracker.wait()).await {
Ok(()) => tracing::info!("event broker publishes drained"),
Err(error) => {
tracing::warn!(
error=?error,
timeout_seconds = EVENT_BROKER_DRAIN_TIMEOUT.as_secs(),
"timed out waiting for event broker publishes to drain"
);
}
}
server_result
}
const EVENT_BROKER_DRAIN_TIMEOUT: Duration = Duration::from_secs(10);