Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

feat: add TrueFoundry shared Daytona sandbox (#597)

Srajan Asthanaac091cc06ed9
diff --git a/.changeset/tfy-daytona-sandbox-mode.md b/.changeset/tfy-daytona-sandbox-mode.md
new file mode 100644
index 000000000..45b95cc21
--- /dev/null
+++ b/.changeset/tfy-daytona-sandbox-mode.md
@@ -0,0 +1,5 @@
+---
+"@truefoundry/trueforge": patch
+---
+
+TrueFoundry mode: shared Daytona sandbox via TRUEFOUNDRY_SANDBOX_* env and settings-server snapshot (lru-cache TTL).
diff --git a/packages/trueforge/.env.example b/packages/trueforge/.env.example
index a9f646a15..d9a0fab3d 100644
--- a/packages/trueforge/.env.example
+++ b/packages/trueforge/.env.example
@@ -46,6 +46,12 @@ PORT=8790
## Directory holding the mTLS cert triple (tls.crt / tls.key / ca.crt) when TRUEFOUNDRY_MTLS_ENABLED=true.
# TRUEFOUNDRY_MTLS_CERTS_DIR=/etc/tls/truefoundry
+## Shared Daytona sandbox for all tenants (TrueFoundry mode only). Snapshot name and lifecycle
+## intervals come from TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL. PUT settings is disabled (424).
+# TRUEFOUNDRY_SANDBOX_ENABLED=false
+# TRUEFOUNDRY_SANDBOX_API_KEY=
+# TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL=https://example.workers.dev/daytona/settings
+
## Optional override for the MCP catalog YAML (GET /catalog/mcp-servers).
## When unset, the catalog inlined at build time (catalog/mcp-catalog.yaml) is used.
# MCP_CATALOG_PATH=/path/to/mcp-catalog.yaml
@@ -130,10 +136,14 @@ REDIS_URL=redis://localhost:6379
# MCP_CONNECT_TIMEOUT_MS=30000
## ---------------------------------------------------------------------------
-## Sandbox process knobs. Provider identity/credentials are configured via
-## PUT /api/v1/settings/sandbox-providers (copy from GET /api/v1/catalog/sandbox-providers). Without a
-## configured provider, agent specs with config.sandbox.enabled (or skills) are
+## Sandbox process knobs.
+##
+## Self-serve (not TrueFoundry mode): configure the provider via
+## PUT /api/v1/settings/sandbox-providers (copy from GET /api/v1/catalogs/sandbox-providers).
+## Without a configured provider, agent specs with config.sandbox.enabled (or skills) are
## rejected at session creation.
+##
+## TrueFoundry mode: see TRUEFOUNDRY_SANDBOX_* above (distributed config only).
## ---------------------------------------------------------------------------
## Max bytes for a single file download out of the sandbox. Default 20 MB (same as gateway).
diff --git a/packages/trueforge/package.json b/packages/trueforge/package.json
index 30cbb7e4f..011b8115c 100644
--- a/packages/trueforge/package.json
+++ b/packages/trueforge/package.json
@@ -74,6 +74,7 @@
"hono": "^4.13.5",
"jose": "^6.2.10",
"kysely": "^0.29.5",
+ "lru-cache": "^11.5.2",
"openid-client": "^6.8.7",
"pg": "^8.23.0",
"redis": "^5.12.1",
diff --git a/packages/trueforge/scripts/write-openapi.ts b/packages/trueforge/scripts/write-openapi.ts
index 279920d2f..9bbdd0a3b 100644
--- a/packages/trueforge/scripts/write-openapi.ts
+++ b/packages/trueforge/scripts/write-openapi.ts
@@ -77,7 +77,7 @@ const app = createServerApp({
skillCatalog: SkillCatalog.load(),
skillStore: new SqliteSkillStore(db),
sandboxCatalog: SandboxCatalog.load(),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
resolveAgentStore: () => agentStore,
scheduleStore: new SqliteScheduleStore(db),
sessionStore,
diff --git a/packages/trueforge/src/apis/agents.ts b/packages/trueforge/src/apis/agents.ts
index 104309f2d..3661d7747 100644
--- a/packages/trueforge/src/apis/agents.ts
+++ b/packages/trueforge/src/apis/agents.ts
@@ -35,7 +35,7 @@ export interface AgentsRouterDeps<TTransaction> {
resolveModelProviderStore: (c: Context) => IModelProviderStore<TTransaction>;
resolveMcpServerStore: (c: Context) => IMcpServerStore<TTransaction>;
skillStore: ISkillStore<TTransaction>;
- sandboxProviderStore: ISandboxProviderStore<TTransaction>;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
resolveRequestContext: ResolveRequestContext;
authorizer: Authorizer;
@@ -56,12 +56,14 @@ async function validateManifest<TTransaction>({
deps,
modelProviderStore,
mcpServerStore,
+ sandboxProviderStore,
tenant_id,
}: {
spec: AgentSpec;
deps: AgentsRouterDeps<TTransaction>;
modelProviderStore: IModelProviderStore<TTransaction>;
mcpServerStore: IMcpServerStore<TTransaction>;
+ sandboxProviderStore: ISandboxProviderStore<TTransaction>;
tenant_id: string;
}): Promise<AgentSpec> {
await validateAgentSpec({
@@ -70,7 +72,7 @@ async function validateManifest<TTransaction>({
modelProviderStore,
mcpServerStore,
skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ sandboxProviderStore,
});
return spec;
}
@@ -95,6 +97,7 @@ export function createAgentsRouter<TTransaction>(deps: AgentsRouterDeps<TTransac
deps,
modelProviderStore: deps.resolveModelProviderStore(c),
mcpServerStore: deps.resolveMcpServerStore(c),
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
tenant_id: requestContext.tenant_id,
});
try {
@@ -186,6 +189,7 @@ export function createAgentsRouter<TTransaction>(deps: AgentsRouterDeps<TTransac
deps,
modelProviderStore: deps.resolveModelProviderStore(c),
mcpServerStore: deps.resolveMcpServerStore(c),
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
tenant_id: requestContext.tenant_id,
});
const record = await deps.resolveAgentStore(c).updateAgent({
diff --git a/packages/trueforge/src/apis/capabilities.ts b/packages/trueforge/src/apis/capabilities.ts
index f3cecde2f..a7cc4151f 100644
--- a/packages/trueforge/src/apis/capabilities.ts
+++ b/packages/trueforge/src/apis/capabilities.ts
@@ -1,5 +1,6 @@
import { OpenAPIHono } from '@hono/zod-openapi';
import { extractErrorLogFields } from '@truefoundry/trueforge-core/core';
+import type { Context } from 'hono';
import type { Logger } from 'winston';
import { hasAdminRole, type ResolveRequestContext } from '../auth/identity';
import type { ISandboxProviderStore } from '../db/sandboxProviderStore';
@@ -21,7 +22,7 @@ function skillDisabledReason(status: SandboxBuildStatus | undefined): string {
}
export function createCapabilitiesRouter<TTransaction>(deps: {
- sandboxProviderStore: ISandboxProviderStore<TTransaction>;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
logger: Logger;
resolveRequestContext: ResolveRequestContext;
@@ -34,7 +35,7 @@ export function createCapabilitiesRouter<TTransaction>(deps: {
let status: SandboxBuildStatus | undefined;
try {
const refreshed = await checkSnapshotStatus({
- store: deps.sandboxProviderStore,
+ store: deps.resolveSandboxProviderStore(c),
tenant_id: requestContext.tenant_id,
logger: deps.logger,
});
diff --git a/packages/trueforge/src/apis/sandboxProviders.ts b/packages/trueforge/src/apis/sandboxProviders.ts
index 843810115..7011bdf5a 100644
--- a/packages/trueforge/src/apis/sandboxProviders.ts
+++ b/packages/trueforge/src/apis/sandboxProviders.ts
@@ -1,5 +1,6 @@
import { OpenAPIHono, type RouteHandler } from '@hono/zod-openapi';
import { withTimeout } from '@truefoundry/trueforge-core/core';
+import type { Context } from 'hono';
import type { Logger } from 'winston';
import type { ResolveRequestContext } from '../auth/identity';
import type { ISandboxProviderStore, SandboxProviderRecord } from '../db/sandboxProviderStore';
@@ -19,7 +20,7 @@ import { MissingStoredSecretError, resolveStoredSecretValue, toRedactedSecretVal
const BUILD_REQUEST_TIMEOUT_MS = 3_000;
export interface SandboxProvidersRouterDeps<TTransaction> {
- sandboxProviderStore: ISandboxProviderStore<TTransaction>;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
logger: Logger;
resolveRequestContext: ResolveRequestContext;
@@ -36,13 +37,14 @@ function redactSandboxProvider(manifest: SandboxProviderManifest): SandboxProvid
export function createSandboxProvidersRouter<TTransaction>(deps: SandboxProvidersRouterDeps<TTransaction>) {
const getHandler: RouteHandler<typeof getSandboxProviderRoute> = async c => {
const requestContext = deps.resolveRequestContext(c);
- const record = await deps.sandboxProviderStore.getSandboxProvider(requestContext.tenant_id);
+ const store = deps.resolveSandboxProviderStore(c);
+ const record = await store.getSandboxProvider(requestContext.tenant_id);
if (record === undefined) {
return c.json({ error: { message: 'No sandbox provider configured' } }, 404);
}
// Refresh the persisted build status (and re-activate an idle snapshot) on every GET.
const status = await checkSnapshotStatus({
- store: deps.sandboxProviderStore,
+ store,
tenant_id: requestContext.tenant_id,
logger: deps.logger,
});
@@ -61,6 +63,7 @@ export function createSandboxProvidersRouter<TTransaction>(deps: SandboxProvider
const putHandler: RouteHandler<typeof putSandboxProviderRoute> = async c => {
const body: UpdateSandboxProviderRequest = c.req.valid('json');
const requestContext = deps.resolveRequestContext(c);
+ const store = deps.resolveSandboxProviderStore(c);
const incoming = body.manifest;
const resolveManifest = (existing: SandboxProviderRecord | undefined): SandboxProviderManifest => ({
...incoming,
@@ -74,10 +77,7 @@ export function createSandboxProvidersRouter<TTransaction>(deps: SandboxProvider
try {
// NOTE: build (Daytona network I/O) runs inside the transaction for now; the design is being revisited.
const { manifest, status } = await deps.withTransaction(async transaction => {
- const locked = await deps.sandboxProviderStore.getSandboxProviderForUpdate(
- requestContext.tenant_id,
- transaction,
- );
+ const locked = await store.getSandboxProviderForUpdate(requestContext.tenant_id, transaction);
const resolved = resolveManifest(locked);
// Pass persisted build_metadata so a settings re-save does not start a new snapshot for a
// bumped SANDBOX_IMAGE_URI (upgrades are unsupported — first configure has no metadata).
@@ -90,7 +90,7 @@ export function createSandboxProvidersRouter<TTransaction>(deps: SandboxProvider
const built = toSandboxStatus(
await withTimeout(provider.buildImage(), BUILD_REQUEST_TIMEOUT_MS, 'sandbox buildImage'),
);
- await deps.sandboxProviderStore.upsertSandboxProvider(
+ await store.upsertSandboxProvider(
{ tenant_id: requestContext.tenant_id, manifest: resolved, ...built },
transaction,
);
diff --git a/packages/trueforge/src/apis/sessions.ts b/packages/trueforge/src/apis/sessions.ts
index d5d771c67..e8993642a 100644
--- a/packages/trueforge/src/apis/sessions.ts
+++ b/packages/trueforge/src/apis/sessions.ts
@@ -79,7 +79,7 @@ export interface SessionsRouterDeps {
resolveMcpServerStore: (c: Context) => IMcpServerStore;
skillStore: ISkillStore;
resolveAgentStore: (c: Context) => IAgentStore;
- sandboxProviderStore: ISandboxProviderStore;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore;
redis?: RedisClientType | undefined;
requestReplyRouter: RequestReplyRouter;
resolveRequestContext: ResolveRequestContext;
@@ -235,7 +235,7 @@ type InternalSessionsRouterDeps = Pick<
| 'resolveMcpServerStore'
| 'skillStore'
| 'resolveAgentStore'
- | 'sandboxProviderStore'
+ | 'resolveSandboxProviderStore'
| 'resolveRequestContext'
| 'authorizer'
>;
@@ -288,7 +288,7 @@ function createGetOrCreateSessionByExternalIdHandler(
modelProviderStore: deps.resolveModelProviderStore(c),
mcpServerStore: deps.resolveMcpServerStore(c),
skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
});
agent = { type: 'inline', spec: body.agent.spec };
}
@@ -360,7 +360,7 @@ export function createSessionsRouter(deps: SessionsRouterDeps) {
modelProviderStore: deps.resolveModelProviderStore(c),
mcpServerStore: deps.resolveMcpServerStore(c),
skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
});
const session = await deps.sessions.create({
tenant_id: requestContext.tenant_id,
@@ -451,7 +451,7 @@ export function createSessionsRouter(deps: SessionsRouterDeps) {
modelProviderStore: deps.resolveModelProviderStore(c),
mcpServerStore: deps.resolveMcpServerStore(c),
skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
});
}
try {
diff --git a/packages/trueforge/src/apis/settings.ts b/packages/trueforge/src/apis/settings.ts
index e1f08654a..f9133d130 100644
--- a/packages/trueforge/src/apis/settings.ts
+++ b/packages/trueforge/src/apis/settings.ts
@@ -23,7 +23,7 @@ export interface SettingsRouterDeps<TTransaction> {
resolveMcpServerStore: (c: Context) => IMcpServerWithAuthStore<TTransaction>;
tokenStore: IOAuthTokenStore<TTransaction>;
skillStore: ISkillStore<TTransaction>;
- sandboxProviderStore: ISandboxProviderStore<TTransaction>;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
logger: Logger;
resolveRequestContext: ResolveRequestContext;
@@ -60,7 +60,7 @@ export function createSettingsRouter<TTransaction>(deps: SettingsRouterDeps<TTra
router.route(
'/sandbox-providers',
createSandboxProvidersRouter({
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
withTransaction: deps.withTransaction,
logger: deps.logger,
resolveRequestContext: deps.resolveRequestContext,
diff --git a/packages/trueforge/src/apis/turns.ts b/packages/trueforge/src/apis/turns.ts
index 4007bc61a..ef639a792 100644
--- a/packages/trueforge/src/apis/turns.ts
+++ b/packages/trueforge/src/apis/turns.ts
@@ -111,7 +111,7 @@ export interface TurnsRouterDeps {
resolveAgentStore: (c: Context) => IAgentStore;
/** Resumable live turn-event transport: create-turn writes, subscribe polls. */
eventSubscriptions: EventSubscriptionRegistry<TurnStreamingEvent>;
- sandboxProviderStore: ISandboxProviderStore;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore;
logger: Logger;
resolveRequestContext: ResolveRequestContext;
authorizer: Authorizer;
@@ -119,16 +119,18 @@ export interface TurnsRouterDeps {
/**
* Deps needed to create a turn and drain events in-process (no HTTP). Carries already-resolved
- * `modelProviderStore` / `mcpServerStore` / `agentStore`, so callers must resolve them from the
- * caller's request context to keep TrueFoundry mode token-bound.
+ * `modelProviderStore` / `mcpServerStore` / `agentStore` / `sandboxProviderStore`; callers must
+ * resolve them from the request context (e.g. schedule `resolveTurnDeps(c)`) so TrueFoundry mode
+ * stays token-bound.
*/
export type BeginTurnExecutionDeps = Pick<
TurnsRouterDeps,
- 'activeTurns' | 'eventSubscriptions' | 'skillStore' | 'sandboxProviderStore' | 'logger'
+ 'activeTurns' | 'eventSubscriptions' | 'skillStore' | 'logger'
> & {
modelProviderStore: IModelProviderStore;
mcpServerStore: IMcpServerWithAuthStore;
agentStore: IAgentStore;
+ sandboxProviderStore: ISandboxProviderStore;
};
/**
@@ -631,7 +633,7 @@ export function createTurnsRouter(deps: TurnsRouterDeps) {
const provider = await resolveSandboxProvider({
tenant_id: requestContext.tenant_id,
- store: deps.sandboxProviderStore,
+ store: deps.resolveSandboxProviderStore(c),
logger: deps.logger,
sessionId,
});
@@ -754,6 +756,7 @@ export function createTurnsRouter(deps: TurnsRouterDeps) {
modelProviderStore: deps.resolveModelProviderStore(c),
mcpServerStore: deps.resolveMcpServerStore(c),
agentStore: deps.resolveAgentStore(c),
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
},
};
diff --git a/packages/trueforge/src/app.ts b/packages/trueforge/src/app.ts
index f2415d8a4..fdc9c2397 100644
--- a/packages/trueforge/src/app.ts
+++ b/packages/trueforge/src/app.ts
@@ -175,10 +175,14 @@ export interface ServerDeps<TTransaction> {
resolveMcpServerStore: (c?: Context) => IMcpServerWithAuthStore<TTransaction>;
/** Per-request store: DB singleton, or a token-bound TrueFoundry decorator in TrueFoundry mode. */
resolveAgentStore: (c: Context) => IAgentStore<TTransaction>;
+ /**
+ * Per-request store: DB singleton, or a token-bound TrueFoundry store in TrueFoundry mode
+ * (env + settings-server Daytona).
+ */
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
tokenStore: IOAuthTokenStore<TTransaction>;
skillStore: ISkillStore<TTransaction>;
- sandboxProviderStore: ISandboxProviderStore<TTransaction>;
scheduleStore: IScheduleStore<TTransaction>;
sessionStore: ISessionStore;
sessionMetricsStore: ISessionMetricsStore;
@@ -227,7 +231,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
'/api/v1/capabilities',
withAuth(
createCapabilitiesRouter({
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
withTransaction: deps.withTransaction,
logger: deps.logger,
resolveRequestContext,
@@ -300,7 +304,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
resolveModelProviderStore: deps.resolveModelProviderStore,
resolveMcpServerStore: deps.resolveMcpServerStore,
skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
withTransaction: deps.withTransaction,
resolveRequestContext,
authorizer: deps.authorizer,
@@ -322,7 +326,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
mcpServerStore: deps.resolveMcpServerStore(c),
skillStore: deps.skillStore,
agentStore: deps.resolveAgentStore(c),
- sandboxProviderStore: deps.sandboxProviderStore,
+ sandboxProviderStore: deps.resolveSandboxProviderStore(c),
logger: deps.logger,
}),
withTransaction: deps.withTransaction,
@@ -340,7 +344,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
resolveMcpServerStore: deps.resolveMcpServerStore,
tokenStore: deps.tokenStore,
skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
withTransaction: deps.withTransaction,
logger: deps.logger,
resolveRequestContext,
@@ -357,7 +361,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
resolveMcpServerStore: deps.resolveMcpServerStore,
skillStore: deps.skillStore,
resolveAgentStore: deps.resolveAgentStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
resolveRequestContext,
authorizer: deps.authorizer,
}),
@@ -387,7 +391,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
resolveMcpServerStore: deps.resolveMcpServerStore,
skillStore: deps.skillStore,
resolveAgentStore: deps.resolveAgentStore,
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
redis: deps.redis,
requestReplyRouter: deps.requestReplyRouter,
resolveRequestContext,
@@ -409,7 +413,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
skillStore: deps.skillStore,
resolveAgentStore: deps.resolveAgentStore,
eventSubscriptions: deps.eventSubscriptions,
- sandboxProviderStore: deps.sandboxProviderStore,
+ resolveSandboxProviderStore: deps.resolveSandboxProviderStore,
logger: deps.logger,
resolveRequestContext,
authorizer: deps.authorizer,
diff --git a/packages/trueforge/src/config.ts b/packages/trueforge/src/config.ts
index de569a071..a6eaf2698 100644
--- a/packages/trueforge/src/config.ts
+++ b/packages/trueforge/src/config.ts
@@ -575,6 +575,22 @@ export type DistributedServerConfiguration = SharedServerConfiguration & {
* Env: `TRUEFOUNDRY_MTLS_CERTS_DIR`. Default `/etc/tls/truefoundry`.
*/
TRUEFOUNDRY_MTLS_CERTS_DIR: string;
+ /**
+ * When TrueFoundry mode is on, enable the shared Daytona sandbox for all tenants
+ * (settings-server snapshot; no per-tenant PUT). Env: `TRUEFOUNDRY_SANDBOX_ENABLED`. Default false.
+ */
+ TRUEFOUNDRY_SANDBOX_ENABLED: boolean;
+ /**
+ * Shared Daytona API key used when `TRUEFOUNDRY_SANDBOX_ENABLED` is true.
+ * Env: `TRUEFOUNDRY_SANDBOX_API_KEY`.
+ */
+ TRUEFOUNDRY_SANDBOX_API_KEY: string | undefined;
+ /**
+ * Trusted internal URL that returns Daytona snapshot name and lifecycle settings
+ * (`snapshotName`, intervals, `timeoutMs`). Used when `TRUEFOUNDRY_SANDBOX_ENABLED` is true.
+ * Env: `TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL`.
+ */
+ TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL: string | undefined;
};
export type ServerConfiguration = StandaloneServerConfiguration | DistributedServerConfiguration;
@@ -735,6 +751,13 @@ const configuration: ServerConfiguration = standalone
}),
TRUEFOUNDRY_MTLS_CERTS_DIR:
getEnv('TRUEFOUNDRY_MTLS_CERTS_DIR', { defaultValue: '/etc/tls/truefoundry' }) ?? '/etc/tls/truefoundry',
+ TRUEFOUNDRY_SANDBOX_ENABLED: parseBoolean({
+ envKey: 'TRUEFOUNDRY_SANDBOX_ENABLED',
+ raw: getEnv('TRUEFOUNDRY_SANDBOX_ENABLED'),
+ defaultValue: false,
+ }),
+ TRUEFOUNDRY_SANDBOX_API_KEY: getEnv('TRUEFOUNDRY_SANDBOX_API_KEY', { required: false }),
+ TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL: getEnv('TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL', { required: false }),
};
export function isOidcConfigured(
@@ -774,11 +797,25 @@ export function getTrueForgeAuthMode(config: ServerConfiguration = configuration
return TrueForgeAuthMode.Standalone;
}
-// TrueFoundry authenticates each caller with their own gateway token, so browser SSO must be off.
-if (isTrueFoundryModeEnabled(configuration) && isOidcConfigured(configuration)) {
- throw new Error(
- 'TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL (TrueFoundry mode) and OIDC (SSO) cannot both be enabled at once.',
- );
+if (isTrueFoundryModeEnabled(configuration)) {
+ // TrueFoundry authenticates each caller with their own gateway token, so browser SSO must be off.
+ if (isOidcConfigured(configuration)) {
+ throw new Error(
+ 'TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL (TrueFoundry mode) and OIDC (SSO) cannot both be enabled at once.',
+ );
+ }
+ // Shared sandbox: TRUEFOUNDRY_SANDBOX_ENABLED requires a provider (Daytona today).
+ if (configuration.TRUEFOUNDRY_SANDBOX_ENABLED) {
+ if (
+ configuration.TRUEFOUNDRY_SANDBOX_API_KEY === undefined ||
+ configuration.TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL === undefined
+ ) {
+ throw new Error(
+ 'TRUEFOUNDRY_SANDBOX_ENABLED is true but no sandbox provider is configured. ' +
+ 'Set TRUEFOUNDRY_SANDBOX_API_KEY + TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL, or set TRUEFOUNDRY_SANDBOX_ENABLED=false.',
+ );
+ }
+ }
}
/**
diff --git a/packages/trueforge/src/main.ts b/packages/trueforge/src/main.ts
index 999f7f330..3c02dfc4f 100644
--- a/packages/trueforge/src/main.ts
+++ b/packages/trueforge/src/main.ts
@@ -91,6 +91,7 @@ import { TrueFoundryAgentStore } from './truefoundry/TrueFoundryAgentStore';
import { TrueFoundryAuthorizer } from './truefoundry/TrueFoundryAuthorizer';
import { TrueFoundryMcpServerStore } from './truefoundry/TrueFoundryMcpServerStore';
import { TrueFoundryModelProviderStore } from './truefoundry/TrueFoundryModelProviderStore';
+import { TrueFoundrySandboxProviderStore } from './truefoundry/TrueFoundrySandboxProviderStore';
import { TrueFoundryServiceFoundryServerClient } from './truefoundry/TrueFoundryServiceFoundryServerClient';
/** Persistence + optional Redis wired for the selected topology. */
@@ -100,10 +101,10 @@ interface ServerPersistence<TTransaction> {
resolveModelProviderStore: (c: Context) => IModelProviderStore<TTransaction>;
resolveMcpServerStore: (c?: Context) => IMcpServerWithAuthStore<TTransaction>;
resolveAgentStore: (c: Context) => IAgentStore<TTransaction>;
+ resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
tokenStore: IOAuthTokenStore<TTransaction>;
skillStore: ISkillStore<TTransaction>;
- sandboxProviderStore: ISandboxProviderStore<TTransaction>;
scheduleStore: IScheduleStore<TTransaction>;
destroyDb: () => Promise<void>;
redis: RedisClientType | undefined;
@@ -115,7 +116,7 @@ function requireRequestCredentialToken(c: Context): string {
const credential = resolveRequestContext(c).user_credential;
if (credential === null) {
throw new HTTPException(401, {
- message: 'Authentication token required to list or call TrueFoundry models, MCP servers, and agents',
+ message: 'Authentication token required to list or call TrueFoundry models, MCP servers, agents, and sandbox',
});
}
return credential;
@@ -202,6 +203,23 @@ function buildResolveAgentStore(options: {
};
}
+/**
+ * Per-request sandbox-provider store resolver. In TrueFoundry mode every request gets a
+ * token-bound env/settings-server store; otherwise the persistence store is reused as-is.
+ */
+function buildResolveSandboxProviderStore<TTransaction>(options: {
+ persistenceStore: ISandboxProviderStore<TTransaction>;
+}): (c: Context) => ISandboxProviderStore<TTransaction> {
+ const { persistenceStore } = options;
+ if (!isTrueFoundryModeEnabled(configuration)) {
+ return () => persistenceStore;
+ }
+ return c =>
+ new TrueFoundrySandboxProviderStore<TTransaction>({
+ accessToken: requireRequestCredentialToken(c),
+ });
+}
+
/** SQLite stores; Redis unused (executor peering disabled). */
async function createStandalonePersistence(options: {
sqlitePath: string;
@@ -249,16 +267,17 @@ async function createStandalonePersistence(options: {
tokenStore,
clientName: configuration.MCP_DCR_OAUTH_CLIENT_NAME,
});
+ const sandboxProviderStore = new SqliteSandboxProviderStore(db);
return {
sessionStore: new SqliteSessionStore(db),
sessionMetricsStore: new SqliteSessionMetricsStore(db),
resolveModelProviderStore: () => modelProviderStore,
resolveMcpServerStore: () => mcpServerStore,
resolveAgentStore: () => agentStore,
+ resolveSandboxProviderStore: () => sandboxProviderStore,
withTransaction: callback => db.transaction().execute(callback),
tokenStore,
skillStore: new SqliteSkillStore(db),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
scheduleStore: new SqliteScheduleStore(db),
destroyDb: () => db.destroy(),
redis: undefined,
@@ -341,10 +360,12 @@ async function createDistributedPersistence(options: {
db,
client: serviceFoundryClient,
}),
+ resolveSandboxProviderStore: buildResolveSandboxProviderStore({
+ persistenceStore: new PostgresSandboxProviderStore(db),
+ }),
withTransaction: callback => db.transaction().execute(callback),
tokenStore,
skillStore: new PostgresSkillStore(db),
- sandboxProviderStore: new PostgresSandboxProviderStore(db),
scheduleStore: new PostgresScheduleStore(db),
destroyDb: () => db.destroy(),
redis: await connectRedis({ url: redisUrl, logger }),
@@ -360,10 +381,10 @@ async function createServerRuntime<TTransaction>(persistence: ServerPersistence<
resolveModelProviderStore,
resolveMcpServerStore,
resolveAgentStore,
+ resolveSandboxProviderStore,
withTransaction,
tokenStore,
skillStore,
- sandboxProviderStore,
scheduleStore,
destroyDb,
redis,
@@ -420,10 +441,10 @@ async function createServerRuntime<TTransaction>(persistence: ServerPersistence<
resolveModelProviderStore,
resolveMcpServerStore,
resolveAgentStore,
+ resolveSandboxProviderStore,
withTransaction,
tokenStore,
skillStore,
- sandboxProviderStore,
scheduleStore,
sessionStore,
sessionMetricsStore,
diff --git a/packages/trueforge/src/sandbox/localRuntime.ts b/packages/trueforge/src/sandbox/localRuntime.ts
index 1b63eb84e..598d544fa 100644
--- a/packages/trueforge/src/sandbox/localRuntime.ts
+++ b/packages/trueforge/src/sandbox/localRuntime.ts
@@ -2,7 +2,7 @@
* Process-scoped local-sandbox probe cache. `isSupported()` inits SRT and
* creates a temp sandbox — run once at standalone boot, never per request.
*/
-import configuration from '../config';
+import configuration, { isTrueFoundryModeEnabled } from '../config';
import type { LocalSandboxSupportResult } from './local/provider/LocalSandboxProvider';
let cachedSupport: LocalSandboxSupportResult | undefined;
@@ -15,7 +15,10 @@ export function getCachedLocalSandboxSupport(): LocalSandboxSupportResult | unde
return cachedSupport;
}
-/** Standalone + cached probe succeeded. No DB row required. */
+/** Standalone + cached probe succeeded. No DB row required. Never in TrueFoundry mode. */
export function isLocalSandboxFallbackEnabled(): boolean {
+ if (isTrueFoundryModeEnabled(configuration)) {
+ return false;
+ }
return configuration.STANDALONE && cachedSupport?.supported === true;
}
diff --git a/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts b/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts
new file mode 100644
index 000000000..cbd09d91d
--- /dev/null
+++ b/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts
@@ -0,0 +1,139 @@
+import { HTTPException } from 'hono/http-exception';
+import { LRUCache } from 'lru-cache';
+import { z } from 'zod';
+import type {
+ ISandboxProviderStore,
+ SandboxProviderRecord,
+ UpdateSandboxStatusInput,
+ UpsertSandboxProviderInput,
+} from '../db/sandboxProviderStore';
+import { resolveTrueFoundrySandboxProviderConfig } from './resolveTrueFoundrySandboxProviderConfig';
+import { TRUEFOUNDRY_MANAGED_MESSAGE, TRUEFOUNDRY_MANAGED_STATUS } from './trueFoundryManaged';
+
+const SETTINGS_CACHE_TTL_MS = 5 * 60 * 1000;
+const SETTINGS_FETCH_TIMEOUT_MS = 10_000;
+
+const SANDBOX_DEFAULT_SETTINGS = {
+ timeoutMs: 60_000,
+ autoStopIntervalInMinutes: 5,
+ autoArchiveIntervalInMinutes: 60,
+ autoDeleteIntervalInMinutes: 43_200,
+} as const;
+
+const DaytonaSandboxSettingsSchema = z.object({
+ snapshotName: z.string().min(1, 'snapshotName is required'),
+ autoStopIntervalInMinutes: z.number().default(SANDBOX_DEFAULT_SETTINGS.autoStopIntervalInMinutes),
+ autoArchiveIntervalInMinutes: z.number().default(SANDBOX_DEFAULT_SETTINGS.autoArchiveIntervalInMinutes),
+ autoDeleteIntervalInMinutes: z.number().default(SANDBOX_DEFAULT_SETTINGS.autoDeleteIntervalInMinutes),
+ timeoutMs: z.number().default(SANDBOX_DEFAULT_SETTINGS.timeoutMs),
+});
+
+type DaytonaSandboxSettings = z.infer<typeof DaytonaSandboxSettingsSchema>;
+
+const DAYTONA_SETTINGS_CACHE_KEY = 'daytona-settings';
+
+/** Process-wide shared settings, TTL refresh, single slot. */
+const daytonaSettingsCache = new LRUCache<string, DaytonaSandboxSettings>({
+ max: 1,
+ ttl: SETTINGS_CACHE_TTL_MS,
+});
+
+async function resolveDaytonaSandboxSettings({
+ accessToken,
+ settingsServerUrl,
+}: {
+ accessToken: string;
+ settingsServerUrl: string;
+}): Promise<DaytonaSandboxSettings> {
+ const cached = daytonaSettingsCache.get(DAYTONA_SETTINGS_CACHE_KEY);
+ if (cached !== undefined) {
+ return cached;
+ }
+ // Deployment settings server (config), not tenant-configurable — trusted like CONTROL_PLANE_URL.
+ let response: Response;
+ try {
+ response = await fetch(settingsServerUrl, {
+ headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}` },
+ signal: AbortSignal.timeout(SETTINGS_FETCH_TIMEOUT_MS),
+ });
+ } catch (error) {
+ const timedOut = error instanceof Error && error.name === 'TimeoutError';
+ throw new Error(
+ timedOut
+ ? `Sandbox settings endpoint timed out after ${String(SETTINGS_FETCH_TIMEOUT_MS / 1000)}s`
+ : 'Sandbox settings endpoint request failed',
+ { cause: error },
+ );
+ }
+ if (!response.ok) {
+ const body = await response.text();
+ throw new Error(`Sandbox settings endpoint returned ${String(response.status)}: ${body}`);
+ }
+ const settings = DaytonaSandboxSettingsSchema.parse(await response.json());
+ daytonaSettingsCache.set(DAYTONA_SETTINGS_CACHE_KEY, settings);
+ return settings;
+}
+
+function managed(): never {
+ throw new HTTPException(TRUEFOUNDRY_MANAGED_STATUS, { message: TRUEFOUNDRY_MANAGED_MESSAGE });
+}
+
+export class TrueFoundrySandboxProviderStore<TTransaction = never> implements ISandboxProviderStore<TTransaction> {
+ readonly #accessToken: string;
+
+ constructor(input: { accessToken: string }) {
+ this.#accessToken = input.accessToken;
+ }
+
+ async getSandboxProvider(tenantId: string, transaction?: TTransaction): Promise<SandboxProviderRecord | undefined> {
+ void transaction;
+ const providerConfig = resolveTrueFoundrySandboxProviderConfig();
+ if (!providerConfig) {
+ return undefined;
+ }
+ const settings = await resolveDaytonaSandboxSettings({
+ accessToken: this.#accessToken,
+ settingsServerUrl: providerConfig.settingsServerUrl,
+ });
+ const now = new Date().toISOString();
+ return {
+ tenant_id: tenantId,
+ manifest: {
+ type: 'daytona',
+ auth: { api_key: providerConfig.apiKey },
+ exec_timeout_ms: settings.timeoutMs,
+ auto_stop_interval_in_minutes: settings.autoStopIntervalInMinutes,
+ auto_archive_interval_in_minutes: settings.autoArchiveIntervalInMinutes,
+ auto_delete_interval_in_minutes: settings.autoDeleteIntervalInMinutes,
+ },
+ status: 'ready',
+ status_reason: null,
+ // Snapshot name only — no image_uri; TFY mode never registers a snapshot.
+ build_metadata: { build_ref: settings.snapshotName },
+ created_at: now,
+ // Fresh on every get so checkSnapshotStatus short-circuits without Daytona.
+ updated_at: now,
+ };
+ }
+
+ getSandboxProviderForUpdate(tenantId: string, transaction: TTransaction): Promise<SandboxProviderRecord | undefined> {
+ void tenantId;
+ void transaction;
+ return managed();
+ }
+
+ upsertSandboxProvider(input: UpsertSandboxProviderInput, transaction?: TTransaction): Promise<SandboxProviderRecord> {
+ void input;
+ void transaction;
+ return managed();
+ }
+
+ updateSandboxStatus(
+ input: UpdateSandboxStatusInput,
+ transaction?: TTransaction,
+ ): Promise<SandboxProviderRecord | undefined> {
+ void input;
+ void transaction;
+ return managed();
+ }
+}
diff --git a/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts b/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts
new file mode 100644
index 000000000..9fc42fb01
--- /dev/null
+++ b/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts
@@ -0,0 +1,38 @@
+import { HTTPException } from 'hono/http-exception';
+import configuration, { type ServerConfiguration } from '../config';
+
+/**
+ * Shared sandbox provider selected by env in TrueFoundry mode.
+ * Daytona today; add a `tfy` branch when `TFY_SANDBOX_SERVER_URL` ships.
+ */
+export interface TrueFoundrySandboxProviderConfig {
+ type: 'daytona';
+ apiKey: string;
+ settingsServerUrl: string;
+}
+
+/**
+ * Returns the configured shared sandbox provider when Daytona env is complete, or undefined.
+ * Must only be called outside standalone (TrueFoundry wiring).
+ */
+export function resolveTrueFoundrySandboxProviderConfig(
+ config: ServerConfiguration = configuration,
+): TrueFoundrySandboxProviderConfig | undefined {
+ if (config.STANDALONE) {
+ throw new HTTPException(500, {
+ message: 'TrueFoundry sandbox provider config is not available in standalone mode',
+ });
+ }
+ if (
+ config.TRUEFOUNDRY_SANDBOX_ENABLED &&
+ config.TRUEFOUNDRY_SANDBOX_API_KEY !== undefined &&
+ config.TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL !== undefined
+ ) {
+ return {
+ type: 'daytona',
+ apiKey: config.TRUEFOUNDRY_SANDBOX_API_KEY,
+ settingsServerUrl: config.TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL,
+ };
+ }
+ return undefined;
+}
diff --git a/packages/trueforge/tests/unit/apis/agents.test.ts b/packages/trueforge/tests/unit/apis/agents.test.ts
index e145afe31..795ce5a12 100644
--- a/packages/trueforge/tests/unit/apis/agents.test.ts
+++ b/packages/trueforge/tests/unit/apis/agents.test.ts
@@ -94,7 +94,7 @@ describe('agents router', () => {
resolveModelProviderStore: () => modelProviderStore,
resolveMcpServerStore: () => new SqliteMcpServerStore(db),
skillStore: new SqliteSkillStore(db),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
withTransaction: callback => db.transaction().execute(callback),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
@@ -104,7 +104,7 @@ describe('agents router', () => {
resolveModelProviderStore: () => modelProviderStore,
resolveMcpServerStore: () => new SqliteMcpServerStore(db),
skillStore: new SqliteSkillStore(db),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
withTransaction: callback => db.transaction().execute(callback),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: denyAllAuthorizer,
diff --git a/packages/trueforge/tests/unit/apis/capabilities.test.ts b/packages/trueforge/tests/unit/apis/capabilities.test.ts
index 2406d378d..5181e79a7 100644
--- a/packages/trueforge/tests/unit/apis/capabilities.test.ts
+++ b/packages/trueforge/tests/unit/apis/capabilities.test.ts
@@ -73,7 +73,7 @@ describe('capabilities routers', () => {
const db = createSqliteDb(':memory:');
return withAuth(
createCapabilitiesRouter({
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
withTransaction: callback => db.transaction().execute(callback),
logger: silentLogger,
resolveRequestContext,
@@ -246,7 +246,7 @@ describe('capabilities routers', () => {
await migrateSqliteToLatest(db);
const router = withAuth(
createCapabilitiesRouter({
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
withTransaction: callback => db.transaction().execute(callback),
logger: silentLogger,
resolveRequestContext,
diff --git a/packages/trueforge/tests/unit/apis/deletedSessionCrud.test.ts b/packages/trueforge/tests/unit/apis/deletedSessionCrud.test.ts
index e86368a2f..3f81fe563 100644
--- a/packages/trueforge/tests/unit/apis/deletedSessionCrud.test.ts
+++ b/packages/trueforge/tests/unit/apis/deletedSessionCrud.test.ts
@@ -50,7 +50,7 @@ describe('public CRUD after session deletion', () => {
resolveMcpServerStore: () => mcpServerStore,
skillStore,
resolveAgentStore: () => agentStore,
- sandboxProviderStore,
+ resolveSandboxProviderStore: () => sandboxProviderStore,
redis: createClient(),
requestReplyRouter: new RequestReplyRouter(),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
@@ -69,7 +69,7 @@ describe('public CRUD after session deletion', () => {
skillStore,
resolveAgentStore: () => agentStore,
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore,
+ resolveSandboxProviderStore: () => sandboxProviderStore,
logger: createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
diff --git a/packages/trueforge/tests/unit/apis/modelProviders.test.ts b/packages/trueforge/tests/unit/apis/modelProviders.test.ts
index 053bde6f0..4c77ea4af 100644
--- a/packages/trueforge/tests/unit/apis/modelProviders.test.ts
+++ b/packages/trueforge/tests/unit/apis/modelProviders.test.ts
@@ -105,7 +105,7 @@ async function createRouters(): Promise<{
}),
tokenStore,
skillStore: new SqliteSkillStore(db),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
withTransaction: callback => db.transaction().execute(callback),
logger: winston.createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
diff --git a/packages/trueforge/tests/unit/apis/sandboxFileDownload.test.ts b/packages/trueforge/tests/unit/apis/sandboxFileDownload.test.ts
index a10343333..1ee5a0953 100644
--- a/packages/trueforge/tests/unit/apis/sandboxFileDownload.test.ts
+++ b/packages/trueforge/tests/unit/apis/sandboxFileDownload.test.ts
@@ -50,7 +50,7 @@ async function buildApp() {
skillStore: new SqliteSkillStore(db),
resolveAgentStore: () => new SqliteAgentStore(db),
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger: createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
diff --git a/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts b/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts
index 6d311f591..0217f83a0 100644
--- a/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts
+++ b/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts
@@ -86,7 +86,7 @@ async function createRouters(): Promise<{
const sandboxProviderStore = new SqliteSandboxProviderStore(db);
return {
settingsRouter: createSandboxProvidersRouter({
- sandboxProviderStore,
+ resolveSandboxProviderStore: () => sandboxProviderStore,
withTransaction: callback => db.transaction().execute(callback),
logger: silentLogger,
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
@@ -113,7 +113,7 @@ describe('sandboxProviders router', () => {
await migrateSqliteToLatest(db);
sandboxProviderStore = new SqliteSandboxProviderStore(db);
settingsRouter = createSandboxProvidersRouter({
- sandboxProviderStore,
+ resolveSandboxProviderStore: () => sandboxProviderStore,
withTransaction: callback => db.transaction().execute(callback),
logger: silentLogger,
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
diff --git a/packages/trueforge/tests/unit/apis/sessionHttp.test.ts b/packages/trueforge/tests/unit/apis/sessionHttp.test.ts
index f45eed38d..9dea62d8e 100644
--- a/packages/trueforge/tests/unit/apis/sessionHttp.test.ts
+++ b/packages/trueforge/tests/unit/apis/sessionHttp.test.ts
@@ -91,7 +91,7 @@ describe('sessions HTTP agent binding', () => {
resolveMcpServerStore: () => mcpServerStore,
skillStore,
resolveAgentStore: () => agentStore,
- sandboxProviderStore,
+ resolveSandboxProviderStore: () => sandboxProviderStore,
redis: createClient(),
requestReplyRouter: new RequestReplyRouter(),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
diff --git a/packages/trueforge/tests/unit/apis/turnHarnessErrorStatus.test.ts b/packages/trueforge/tests/unit/apis/turnHarnessErrorStatus.test.ts
index 4b2051b28..f9fc4d1f7 100644
--- a/packages/trueforge/tests/unit/apis/turnHarnessErrorStatus.test.ts
+++ b/packages/trueforge/tests/unit/apis/turnHarnessErrorStatus.test.ts
@@ -78,7 +78,7 @@ async function postTurnRejectingWith(error: AgentHarnessError): Promise<Response
skillStore: new SqliteSkillStore(db),
resolveAgentStore: () => new SqliteAgentStore(db),
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger: createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
diff --git a/packages/trueforge/tests/unit/apis/turns.test.ts b/packages/trueforge/tests/unit/apis/turns.test.ts
index 418a8331f..56ac3d65f 100644
--- a/packages/trueforge/tests/unit/apis/turns.test.ts
+++ b/packages/trueforge/tests/unit/apis/turns.test.ts
@@ -70,7 +70,7 @@ describe('turns', () => {
skillStore: new SqliteSkillStore(db),
resolveAgentStore: () => new SqliteAgentStore(db),
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger: createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
@@ -146,7 +146,7 @@ describe('turns', () => {
skillStore: new SqliteSkillStore(db),
resolveAgentStore: () => agentStore,
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger: createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: {
@@ -273,7 +273,7 @@ describe('turns', () => {
resolveMcpServerStore: () => mcpServerStoreWithAuth(db, tokenStore),
skillStore: new SqliteSkillStore(db),
eventSubscriptions,
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger,
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
@@ -380,7 +380,7 @@ describe('turns', () => {
skillStore: new SqliteSkillStore(db),
resolveAgentStore: () => new SqliteAgentStore(db),
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger,
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer: new TrueForgeAuthorizer(),
@@ -460,7 +460,7 @@ describe('turns', () => {
skillStore: new SqliteSkillStore(db),
resolveAgentStore: () => agentStore,
eventSubscriptions: new EventSubscriptionRegistry(undefined),
- sandboxProviderStore: new SqliteSandboxProviderStore(db),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
logger: createLogger({ silent: true }),
resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
authorizer,
diff --git a/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts b/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts
new file mode 100644
index 000000000..a3cdf6d10
--- /dev/null
+++ b/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts
@@ -0,0 +1,132 @@
+import { resolveTrueFoundrySandboxProviderConfig } from '../../../src/truefoundry/resolveTrueFoundrySandboxProviderConfig';
+import { TRUEFOUNDRY_MANAGED_MESSAGE, TRUEFOUNDRY_MANAGED_STATUS } from '../../../src/truefoundry/trueFoundryManaged';
+import { TrueFoundrySandboxProviderStore } from '../../../src/truefoundry/TrueFoundrySandboxProviderStore';
+
+jest.mock('../../../src/truefoundry/resolveTrueFoundrySandboxProviderConfig', () => {
+ const resolveTrueFoundrySandboxProviderConfig = jest.fn();
+ return {
+ __esModule: true,
+ resolveTrueFoundrySandboxProviderConfig,
+ };
+});
+
+const mockResolveConfig = resolveTrueFoundrySandboxProviderConfig as jest.MockedFunction<
+ typeof resolveTrueFoundrySandboxProviderConfig
+>;
+
+const ACCESS_TOKEN = 'caller-token';
+const TENANT = 'acme';
+const SETTINGS_BODY = {
+ snapshotName: 'tfy-sandbox-snap',
+ autoStopIntervalInMinutes: 10,
+ autoArchiveIntervalInMinutes: 90,
+ autoDeleteIntervalInMinutes: 10_000,
+ timeoutMs: 90_000,
+};
+
+function mockSettingsFetch(body: unknown = SETTINGS_BODY, status = 200): jest.Mock {
+ const fetchMock = jest.fn().mockResolvedValue({
+ ok: status >= 200 && status < 300,
+ status,
+ text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
+ json: async () => body,
+ });
+ global.fetch = fetchMock as typeof fetch;
+ return fetchMock;
+}
+
+describe('TrueFoundrySandboxProviderStore', () => {
+ beforeEach(() => {
+ mockResolveConfig.mockReset();
+ mockResolveConfig.mockReturnValue({
+ type: 'daytona',
+ apiKey: 'dtn-shared-key',
+ settingsServerUrl: 'https://settings.example/daytona/settings',
+ });
+ });
+
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
+ it('get returns undefined when shared sandbox is not configured', async () => {
+ mockResolveConfig.mockReturnValue(undefined);
+ const fetchMock = mockSettingsFetch();
+ const store = new TrueFoundrySandboxProviderStore({ accessToken: ACCESS_TOKEN });
+ await expect(store.getSandboxProvider(TENANT)).resolves.toBeUndefined();
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
+ it('get fails when settings fetch times out', async () => {
+ const timeout = new Error('The operation was aborted due to timeout');
+ timeout.name = 'TimeoutError';
+ global.fetch = jest.fn().mockRejectedValue(timeout) as typeof fetch;
+ const store = new TrueFoundrySandboxProviderStore({ accessToken: ACCESS_TOKEN });
+
+ await expect(store.getSandboxProvider(TENANT)).rejects.toThrow('Sandbox settings endpoint timed out after 10s');
+ });
+
+ it('get returns ready Daytona record with snapshot build_ref from settings server', async () => {
+ const fetchMock = mockSettingsFetch();
+ const store = new TrueFoundrySandboxProviderStore({ accessToken: ACCESS_TOKEN });
+
+ const record = await store.getSandboxProvider(TENANT);
+
+ expect(fetchMock).toHaveBeenCalledWith('https://settings.example/daytona/settings', {
+ headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${ACCESS_TOKEN}` },
+ signal: expect.any(AbortSignal),
+ });
+ expect(record).toMatchObject({
+ tenant_id: TENANT,
+ status: 'ready',
+ status_reason: null,
+ build_metadata: { build_ref: SETTINGS_BODY.snapshotName },
+ manifest: {
+ type: 'daytona',
+ auth: { api_key: 'dtn-shared-key' },
+ exec_timeout_ms: SETTINGS_BODY.timeoutMs,
+ auto_stop_interval_in_minutes: SETTINGS_BODY.autoStopIntervalInMinutes,
+ auto_archive_interval_in_minutes: SETTINGS_BODY.autoArchiveIntervalInMinutes,
+ auto_delete_interval_in_minutes: SETTINGS_BODY.autoDeleteIntervalInMinutes,
+ },
+ });
+ });
+
+ it('writes and get-for-update are managed (424)', () => {
+ const store = new TrueFoundrySandboxProviderStore({ accessToken: ACCESS_TOKEN });
+ const assertManaged = (run: () => unknown) => {
+ try {
+ run();
+ throw new Error('expected managed HTTPException');
+ } catch (error) {
+ expect(error).toMatchObject({ status: TRUEFOUNDRY_MANAGED_STATUS, message: TRUEFOUNDRY_MANAGED_MESSAGE });
+ }
+ };
+
+ assertManaged(() => store.getSandboxProviderForUpdate(TENANT, null as never));
+ assertManaged(() =>
+ store.upsertSandboxProvider({
+ tenant_id: TENANT,
+ manifest: {
+ type: 'daytona',
+ auth: { api_key: 'x' },
+ exec_timeout_ms: 60_000,
+ auto_stop_interval_in_minutes: 5,
+ auto_archive_interval_in_minutes: 60,
+ auto_delete_interval_in_minutes: 7200,
+ },
+ status: 'ready',
+ status_reason: null,
+ build_metadata: null,
+ }),
+ );
+ assertManaged(() =>
+ store.updateSandboxStatus({
+ tenant_id: TENANT,
+ status: 'ready',
+ status_reason: null,
+ build_metadata: null,
+ }),
+ );
+ });
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7b03d6b62..589ebd40e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -159,6 +159,9 @@ importers:
kysely:
specifier: ^0.29.5
version: 0.29.5
+ lru-cache:
+ specifier: ^11.5.2
+ version: 11.5.2
openid-client:
specifier: ^6.8.7
version: 6.8.7
@@ -5860,6 +5863,10 @@ packages:
resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
+ resolution: {integrity: sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==}
+ engines: {node: 20 || >=22}
+
resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
@@ -13580,6 +13587,8 @@ snapshots:
+
dependencies:
yallist: 3.1.1