Skip to content

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

feat: add TrueFoundry shared TFY sandbox (#632)

Srajan Asthana44f9cbed53ad
diff --git a/.changeset/tfy-sandbox-manifest-union.md b/.changeset/tfy-sandbox-manifest-union.md
new file mode 100644
index 000000000..5e178d629
--- /dev/null
+++ b/.changeset/tfy-sandbox-manifest-union.md
@@ -0,0 +1,7 @@
+---
+"@truefoundry/trueforge": patch
+"@truefoundry/trueforge-core": patch
+"@truefoundry/trueforge-sdk": patch
+---
+
+TrueFoundry mode: env-backed Daytona | truefoundry sandbox via TRUEFOUNDRY_SANDBOX_* (static SETTINGS JSON). Settings OpenAPI stays Daytona-only (`SandboxProviderManifest`); truefoundry is store-internal (`StoredSandboxProviderManifest`).
diff --git a/packages/trueforge-core/src/core/sandbox/provider/TFYSandboxProvider.ts b/packages/trueforge-core/src/core/sandbox/provider/TFYSandboxProvider.ts
index 03b6562ca..2db77cf2b 100644
--- a/packages/trueforge-core/src/core/sandbox/provider/TFYSandboxProvider.ts
+++ b/packages/trueforge-core/src/core/sandbox/provider/TFYSandboxProvider.ts
@@ -61,7 +61,7 @@ interface StatResult {
}
export class TFYSandboxProvider implements SandboxProvider {
- readonly type = 'tfy';
+ readonly type = 'truefoundry';
private readonly serverUrl: string;
private readonly natsBridgeUrl: string;
private readonly tenantName: string;
diff --git a/packages/trueforge/.env.example b/packages/trueforge/.env.example
index 5b48d8ebc..3766f9e44 100644
--- a/packages/trueforge/.env.example
+++ b/packages/trueforge/.env.example
@@ -48,11 +48,16 @@ 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).
+## Shared sandbox for all tenants (TrueFoundry mode only). PUT settings is disabled (424).
# TRUEFOUNDRY_SANDBOX_ENABLED=false
+# TRUEFOUNDRY_SANDBOX_PROVIDER=daytona
+## Required for daytona; optional for truefoundry.
# TRUEFOUNDRY_SANDBOX_API_KEY=
-# TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL=https://example.workers.dev/daytona/settings
+## Required when provider is truefoundry.
+# TRUEFOUNDRY_SANDBOX_SERVER_URL=http://sandbox-server
+## Static JSON settings (provider-specific). Daytona: snapshot + timeouts. TrueFoundry: nats_bridge_url.
+# TRUEFOUNDRY_SANDBOX_SETTINGS={"snapshotName":"my-snap","timeoutMs":60000,"autoStopIntervalInMinutes":5,"autoArchiveIntervalInMinutes":60,"autoDeleteIntervalInMinutes":43200}
+# TRUEFOUNDRY_SANDBOX_SETTINGS={"nats_bridge_url":"ws://nats-bridge"}
## 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.
diff --git a/packages/trueforge/package.json b/packages/trueforge/package.json
index 8045eba7e..dc382fa09 100644
--- a/packages/trueforge/package.json
+++ b/packages/trueforge/package.json
@@ -74,7 +74,6 @@
"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/src/apis/sandboxProviders.ts b/packages/trueforge/src/apis/sandboxProviders.ts
index 7011bdf5a..3b713ca02 100644
--- a/packages/trueforge/src/apis/sandboxProviders.ts
+++ b/packages/trueforge/src/apis/sandboxProviders.ts
@@ -39,7 +39,7 @@ export function createSandboxProvidersRouter<TTransaction>(deps: SandboxProvider
const requestContext = deps.resolveRequestContext(c);
const store = deps.resolveSandboxProviderStore(c);
const record = await store.getSandboxProvider(requestContext.tenant_id);
- if (record === undefined) {
+ if (record?.manifest.type !== 'daytona') {
return c.json({ error: { message: 'No sandbox provider configured' } }, 404);
}
// Refresh the persisted build status (and re-activate an idle snapshot) on every GET.
@@ -70,7 +70,7 @@ export function createSandboxProvidersRouter<TTransaction>(deps: SandboxProvider
auth: {
api_key: resolveStoredSecretValue({
incoming: incoming.auth.api_key,
- existing: existing?.manifest.auth.api_key,
+ existing: existing?.manifest.type === 'daytona' ? existing.manifest.auth.api_key : undefined,
}),
},
});
diff --git a/packages/trueforge/src/app.ts b/packages/trueforge/src/app.ts
index 2fcc996e5..b26d54f21 100644
--- a/packages/trueforge/src/app.ts
+++ b/packages/trueforge/src/app.ts
@@ -176,8 +176,8 @@ export interface ServerDeps<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).
+ * Per-request store: DB singleton, or the env-backed shared store in TrueFoundry mode
+ * (`TRUEFOUNDRY_SANDBOX_*` + static SETTINGS JSON).
*/
resolveSandboxProviderStore: (c: Context) => ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
diff --git a/packages/trueforge/src/config.ts b/packages/trueforge/src/config.ts
index 52c3679af..74f0ebb9e 100644
--- a/packages/trueforge/src/config.ts
+++ b/packages/trueforge/src/config.ts
@@ -141,6 +141,19 @@ function parseBoolean(options: { envKey: string; raw: string | undefined; defaul
throw new Error(`Environment variable ${envKey} must be "true" or "false", got "${raw}"`);
}
+function parseTrueFoundrySandboxProvider(raw: string | undefined): 'daytona' | 'truefoundry' | undefined {
+ if (raw === undefined || raw.trim() === '') {
+ return undefined;
+ }
+ const value = raw.trim();
+ if (value === 'daytona' || value === 'truefoundry') {
+ return value;
+ }
+ throw new Error(
+ `Environment variable TRUEFOUNDRY_SANDBOX_PROVIDER must be "daytona" or "truefoundry", got ${JSON.stringify(raw)}`,
+ );
+}
+
/** Parses `POSTGRES_SSL_MODE`. Unset/blank → `''`. Unknown values throw. */
function parsePostgresSslMode(raw: string | undefined): string {
if (!raw) {
@@ -580,21 +593,31 @@ export type DistributedServerConfiguration = SharedServerConfiguration & {
*/
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.
+ * When TrueFoundry mode is on, enable the shared sandbox for all tenants
+ * (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.
+ * Shared sandbox backend when `TRUEFOUNDRY_SANDBOX_ENABLED` is true.
+ * Env: `TRUEFOUNDRY_SANDBOX_PROVIDER` (`daytona` | `truefoundry`).
+ */
+ TRUEFOUNDRY_SANDBOX_PROVIDER: 'daytona' | 'truefoundry' | undefined;
+ /**
+ * Shared API key (required for Daytona; optional for truefoundry).
* 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 (on-prem) sandbox HTTP server URL when provider is `truefoundry`.
+ * Env: `TRUEFOUNDRY_SANDBOX_SERVER_URL`.
*/
- TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL: string | undefined;
+ TRUEFOUNDRY_SANDBOX_SERVER_URL: string | undefined;
+ /**
+ * Static JSON settings for the shared sandbox (provider-specific).
+ * Daytona: `snapshotName`, intervals, `timeoutMs`. TrueFoundry: `nats_bridge_url`.
+ * Env: `TRUEFOUNDRY_SANDBOX_SETTINGS`.
+ */
+ TRUEFOUNDRY_SANDBOX_SETTINGS: string | undefined;
};
export type ServerConfiguration = StandaloneServerConfiguration | DistributedServerConfiguration;
@@ -761,8 +784,12 @@ const configuration: ServerConfiguration = standalone
raw: getEnv('TRUEFOUNDRY_SANDBOX_ENABLED'),
defaultValue: false,
}),
+ TRUEFOUNDRY_SANDBOX_PROVIDER: parseTrueFoundrySandboxProvider(
+ getEnv('TRUEFOUNDRY_SANDBOX_PROVIDER', { required: 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 }),
+ TRUEFOUNDRY_SANDBOX_SERVER_URL: getEnv('TRUEFOUNDRY_SANDBOX_SERVER_URL', { required: false }),
+ TRUEFOUNDRY_SANDBOX_SETTINGS: getEnv('TRUEFOUNDRY_SANDBOX_SETTINGS', { required: false }),
};
export function isOidcConfigured(
@@ -813,15 +840,40 @@ if (isTrueFoundryModeEnabled(configuration)) {
if (configuration.TRUEFOUNDRY_API_KEY === undefined) {
throw new Error('TRUEFOUNDRY_API_KEY is required when TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL is set.');
}
- // Shared sandbox: TRUEFOUNDRY_SANDBOX_ENABLED requires a provider (Daytona today).
+
+ // Shared sandbox
if (configuration.TRUEFOUNDRY_SANDBOX_ENABLED) {
+ if (configuration.TRUEFOUNDRY_SANDBOX_PROVIDER === undefined) {
+ throw new Error(
+ 'TRUEFOUNDRY_SANDBOX_ENABLED is true but TRUEFOUNDRY_SANDBOX_PROVIDER is not set. ' +
+ 'Set TRUEFOUNDRY_SANDBOX_PROVIDER to "daytona" or "truefoundry", or set TRUEFOUNDRY_SANDBOX_ENABLED=false.',
+ );
+ }
+ if (configuration.TRUEFOUNDRY_SANDBOX_SETTINGS === undefined) {
+ throw new Error(
+ 'TRUEFOUNDRY_SANDBOX_ENABLED is true but TRUEFOUNDRY_SANDBOX_SETTINGS is not set. ' +
+ 'Provide a JSON settings object, or set TRUEFOUNDRY_SANDBOX_ENABLED=false.',
+ );
+ }
+ try {
+ JSON.parse(configuration.TRUEFOUNDRY_SANDBOX_SETTINGS);
+ } catch (error) {
+ throw new Error('TRUEFOUNDRY_SANDBOX_SETTINGS must be valid JSON', { cause: error });
+ }
+ if (
+ configuration.TRUEFOUNDRY_SANDBOX_PROVIDER === 'daytona' &&
+ configuration.TRUEFOUNDRY_SANDBOX_API_KEY === undefined
+ ) {
+ throw new Error(
+ 'TRUEFOUNDRY_SANDBOX_PROVIDER=daytona requires TRUEFOUNDRY_SANDBOX_API_KEY, or set TRUEFOUNDRY_SANDBOX_ENABLED=false.',
+ );
+ }
if (
- configuration.TRUEFOUNDRY_SANDBOX_API_KEY === undefined ||
- configuration.TRUEFOUNDRY_SANDBOX_SETTINGS_SERVER_URL === undefined
+ configuration.TRUEFOUNDRY_SANDBOX_PROVIDER === 'truefoundry' &&
+ configuration.TRUEFOUNDRY_SANDBOX_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.',
+ 'TRUEFOUNDRY_SANDBOX_PROVIDER=truefoundry requires TRUEFOUNDRY_SANDBOX_SERVER_URL, or set TRUEFOUNDRY_SANDBOX_ENABLED=false.',
);
}
}
diff --git a/packages/trueforge/src/db/postgres/types.ts b/packages/trueforge/src/db/postgres/types.ts
index 17475d47e..357ea5877 100644
--- a/packages/trueforge/src/db/postgres/types.ts
+++ b/packages/trueforge/src/db/postgres/types.ts
@@ -25,7 +25,11 @@ import type { CurrentContextUsage } from '@truefoundry/trueforge-core/core/runti
import type { ColumnType, Generated, JSONColumnType } from 'kysely';
import type { McpServerManifest } from '../../schemas/mcpServer';
import type { ModelProviderManifest } from '../../schemas/modelProvider';
-import type { SandboxBuildMetadata, SandboxBuildStatus, SandboxProviderManifest } from '../../schemas/sandboxProvider';
+import type {
+ SandboxBuildMetadata,
+ SandboxBuildStatus,
+ StoredSandboxProviderManifest,
+} from '../../schemas/sandboxProvider';
import type { ScheduleManifest, ScheduleRunStatus, ScheduleStatus } from '../../schemas/schedule';
import type { SkillManifest } from '../../schemas/skill';
import type { OAuthClient, OAuthPendingAuthorizationData, OAuthServer, OAuthToken } from '../mcpServerStore';
@@ -357,8 +361,8 @@ export interface SkillTable {
export interface SandboxProviderTable {
/** key */
tenant_id: string;
- /** SandboxProviderManifest document; replaced whole on every upsert */
- manifest: JSONColumnType<SandboxProviderManifest, SandboxProviderManifest, SandboxProviderManifest>;
+ /** StoredSandboxProviderManifest document; replaced whole on every upsert */
+ manifest: JSONColumnType<StoredSandboxProviderManifest, StoredSandboxProviderManifest, StoredSandboxProviderManifest>;
/** Last persisted build status of the release sandbox image. */
status: SandboxBuildStatus;
/** Human-readable detail for `status`; null when ready. */
diff --git a/packages/trueforge/src/db/sandboxProviderStore.ts b/packages/trueforge/src/db/sandboxProviderStore.ts
index 59eaa47d3..55d25942f 100644
--- a/packages/trueforge/src/db/sandboxProviderStore.ts
+++ b/packages/trueforge/src/db/sandboxProviderStore.ts
@@ -1,14 +1,18 @@
/**
* DB-backed configured sandbox provider: at most one row per tenant. Persists the
- * Zod-validated `SandboxProviderManifest` jsonb document plus the last-known build
+ * Zod-validated `StoredSandboxProviderManifest` jsonb document plus the last-known build
* status (`status` / `status_reason` / `build_metadata`), refreshed on read.
* Implementations: PostgresSandboxProviderStore and SqliteSandboxProviderStore.
*/
-import type { SandboxBuildMetadata, SandboxBuildStatus, SandboxProviderManifest } from '../schemas/sandboxProvider';
+import type {
+ SandboxBuildMetadata,
+ SandboxBuildStatus,
+ StoredSandboxProviderManifest,
+} from '../schemas/sandboxProvider';
export interface SandboxProviderRecord {
tenant_id: string;
- manifest: SandboxProviderManifest;
+ manifest: StoredSandboxProviderManifest;
/** Last persisted build status of the release sandbox image. */
status: SandboxBuildStatus;
/** Human-readable detail for `status`; null when ready. */
@@ -23,7 +27,7 @@ export interface SandboxProviderRecord {
export interface UpsertSandboxProviderInput {
tenant_id: string;
- manifest: SandboxProviderManifest;
+ manifest: StoredSandboxProviderManifest;
status: SandboxBuildStatus;
status_reason: string | null;
build_metadata: SandboxBuildMetadata | null;
diff --git a/packages/trueforge/src/db/sqlite/sandbox-provider-store/SqliteSandboxProviderStore.ts b/packages/trueforge/src/db/sqlite/sandbox-provider-store/SqliteSandboxProviderStore.ts
index 6550f12ad..a52acd5d8 100644
--- a/packages/trueforge/src/db/sqlite/sandbox-provider-store/SqliteSandboxProviderStore.ts
+++ b/packages/trueforge/src/db/sqlite/sandbox-provider-store/SqliteSandboxProviderStore.ts
@@ -1,5 +1,5 @@
import type { ExpressionBuilder, Kysely, Transaction } from 'kysely';
-import type { SandboxBuildMetadata, SandboxProviderManifest } from '../../../schemas/sandboxProvider';
+import type { SandboxBuildMetadata, StoredSandboxProviderManifest } from '../../../schemas/sandboxProvider';
import {
type ISandboxProviderStore,
type SandboxProviderRecord,
@@ -13,7 +13,7 @@ import type { Database } from '../types';
function recordColumns(eb: ExpressionBuilder<Database, 'sandbox_provider'>) {
return [
'tenant_id' as const,
- jsonText<SandboxProviderManifest>(eb.ref('manifest')).as('manifest'),
+ jsonText<StoredSandboxProviderManifest>(eb.ref('manifest')).as('manifest'),
'status' as const,
'status_reason' as const,
jsonText<SandboxBuildMetadata>(eb.ref('build_metadata')).as('build_metadata'),
diff --git a/packages/trueforge/src/db/sqlite/types.ts b/packages/trueforge/src/db/sqlite/types.ts
index 476047b5d..40cd28aa1 100644
--- a/packages/trueforge/src/db/sqlite/types.ts
+++ b/packages/trueforge/src/db/sqlite/types.ts
@@ -28,7 +28,11 @@ import type { CurrentContextUsage } from '@truefoundry/trueforge-core/core/runti
import type { ColumnType, Generated, JSONColumnType } from 'kysely';
import type { McpServerManifest } from '../../schemas/mcpServer';
import type { ModelProviderManifest } from '../../schemas/modelProvider';
-import type { SandboxBuildMetadata, SandboxBuildStatus, SandboxProviderManifest } from '../../schemas/sandboxProvider';
+import type {
+ SandboxBuildMetadata,
+ SandboxBuildStatus,
+ StoredSandboxProviderManifest,
+} from '../../schemas/sandboxProvider';
import type { ScheduleManifest, ScheduleRunStatus, ScheduleStatus } from '../../schemas/schedule';
import type { SkillManifest } from '../../schemas/skill';
import type { OAuthClient, OAuthPendingAuthorizationData, OAuthServer, OAuthToken } from '../mcpServerStore';
@@ -201,8 +205,8 @@ export interface SkillTable {
*/
export interface SandboxProviderTable {
tenant_id: string;
- /** SandboxProviderManifest document; replaced whole on every upsert */
- manifest: JsonbColumn<SandboxProviderManifest>;
+ /** StoredSandboxProviderManifest document; replaced whole on every upsert */
+ manifest: JsonbColumn<StoredSandboxProviderManifest>;
/** Last persisted build status of the release sandbox image. */
status: SandboxBuildStatus;
/** Human-readable detail for `status`; null when ready. */
diff --git a/packages/trueforge/src/main.ts b/packages/trueforge/src/main.ts
index 84f423d36..c16319812 100644
--- a/packages/trueforge/src/main.ts
+++ b/packages/trueforge/src/main.ts
@@ -209,8 +209,8 @@ 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.
+ * Sandbox-provider store resolver. In TrueFoundry mode the shared env-backed store is reused;
+ * otherwise the persistence store is reused as-is.
*/
function buildResolveSandboxProviderStore<TTransaction>(options: {
persistenceStore: ISandboxProviderStore<TTransaction>;
@@ -219,10 +219,8 @@ function buildResolveSandboxProviderStore<TTransaction>(options: {
if (!isTrueFoundryModeEnabled(configuration)) {
return () => persistenceStore;
}
- return c =>
- new TrueFoundrySandboxProviderStore<TTransaction>({
- context: resolveRequestContext(c),
- });
+ const trueFoundryStore = new TrueFoundrySandboxProviderStore<TTransaction>();
+ return () => trueFoundryStore;
}
/** SQLite stores; Redis unused (executor peering disabled). */
diff --git a/packages/trueforge/src/runtime/sessionResources.ts b/packages/trueforge/src/runtime/sessionResources.ts
index c33550a42..086210e4e 100644
--- a/packages/trueforge/src/runtime/sessionResources.ts
+++ b/packages/trueforge/src/runtime/sessionResources.ts
@@ -21,7 +21,7 @@ import type { ISandboxProviderStore } from '../db/sandboxProviderStore';
import type { ISkillStore } from '../db/skillStore';
import { LocalSandboxProvider } from '../sandbox/local/provider/LocalSandboxProvider';
import { getCachedLocalSandboxSupport, isLocalSandboxFallbackEnabled } from '../sandbox/localRuntime';
-import { toDaytonaSandboxProvider } from '../sandbox/providerUtils';
+import { toSandboxProviderFromRecord } from '../sandbox/providerUtils';
import type { ReasoningEffort } from '../schemas/modelProvider';
export interface McpConnection {
@@ -169,7 +169,7 @@ export async function resolveGitSkills({
/**
* Build a runtime SandboxProvider from the configured store row, or the
* in-memory local fallback when standalone + the cached probe is supported.
- * Builds a fresh Daytona client per call (no network I/O).
+ * Builds a fresh provider client per call (no network I/O).
*/
/** Single path segment under the sandboxes parent (`_` when sessionId is missing or unsafe). */
export function localSandboxSessionSegment(sessionId: string | undefined): string {
@@ -192,14 +192,7 @@ export async function resolveSandboxProvider({
}): Promise<SandboxProvider | undefined> {
const record = await store.getSandboxProvider(tenant_id);
if (record !== undefined) {
- // Clone from the snapshot that was actually built (persisted build_ref), not a name
- // derived from the current image — otherwise an image bump breaks creation until rebuild.
- return toDaytonaSandboxProvider({
- manifest: record.manifest,
- tenant_id,
- logger,
- build_metadata: record.build_metadata,
- });
+ return toSandboxProviderFromRecord({ record, tenant_id, logger });
}
if (!configuration.STANDALONE) {
return undefined;
diff --git a/packages/trueforge/src/sandbox/providerUtils.ts b/packages/trueforge/src/sandbox/providerUtils.ts
index 0d815dc36..f65f99350 100644
--- a/packages/trueforge/src/sandbox/providerUtils.ts
+++ b/packages/trueforge/src/sandbox/providerUtils.ts
@@ -1,10 +1,12 @@
-/** Daytona provider construction + persisted build-status refresh (see checkSnapshotStatus). */
+/** Sandbox provider construction + Daytona snapshot status refresh. */
import { Daytona, DaytonaError } from '@daytona/sdk';
import {
DaytonaSandboxProvider,
SANDBOX_IMAGE_URI,
+ TFYSandboxProvider,
withTimeout,
type SandboxBuild,
+ type SandboxProvider,
} from '@truefoundry/trueforge-core/core';
import type { Logger } from 'winston';
import configuration from '../config';
@@ -26,7 +28,7 @@ export function isDaytonaPermissionError(error: unknown): boolean {
}
/**
- * Builds the runtime provider for a stored manifest. No network I/O until a method is called.
+ * Builds the Daytona runtime provider for a stored Daytona manifest. No network I/O until a method is called.
*
* When `build_metadata` is present, pin both `sandboxImage` and `buildRef` to what was actually
* built — image bumps in the running binary must not rewrite an existing tenant onto a new
@@ -57,6 +59,39 @@ export function toDaytonaSandboxProvider({
});
}
+/**
+ * Builds the runtime SandboxProvider for a store record. One switch on `manifest.type`.
+ * No network I/O until a provider method is called.
+ */
+export function toSandboxProviderFromRecord({
+ record,
+ tenant_id,
+ logger,
+}: {
+ record: SandboxProviderRecord;
+ tenant_id: string;
+ logger: Logger;
+}): SandboxProvider {
+ switch (record.manifest.type) {
+ case 'daytona':
+ return toDaytonaSandboxProvider({
+ manifest: record.manifest,
+ tenant_id,
+ logger,
+ build_metadata: record.build_metadata,
+ });
+ case 'truefoundry':
+ return new TFYSandboxProvider({
+ serverUrl: record.manifest.server_url,
+ natsBridgeUrl: record.manifest.nats_bridge_url,
+ tenantName: tenant_id,
+ fileMaxBytesForDownload: configuration.SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD,
+ defaultExecTimeoutMs: record.manifest.exec_timeout_ms,
+ logger,
+ });
+ }
+}
+
/** Maps a core `SandboxBuild` onto the persisted/wire status shape (metadata passes through). */
export function toSandboxStatus(build: SandboxBuild): SandboxStatus {
return {
@@ -96,6 +131,11 @@ export async function checkSnapshotStatus({
const persisted = sandboxStatusFromRecord(record);
+ // Prebuilt image — no snapshot registration or refresh.
+ if (record.manifest.type === 'truefoundry') {
+ return persisted;
+ }
+
const readyIsFresh =
record.status === 'ready' && Date.now() - Date.parse(record.updated_at) < READY_REVALIDATE_INTERVAL_MS;
if (record.status === 'failed' || readyIsFresh) {
diff --git a/packages/trueforge/src/schemas/sandboxProvider.ts b/packages/trueforge/src/schemas/sandboxProvider.ts
index a856c9bdc..380ed8c6d 100644
--- a/packages/trueforge/src/schemas/sandboxProvider.ts
+++ b/packages/trueforge/src/schemas/sandboxProvider.ts
@@ -3,6 +3,9 @@
* request/response shapes. Catalog file schemas live in sandboxCatalog.ts.
*
* Singleton per tenant — no identity `name` (unlike model providers / skills).
+ *
+ * Settings OpenAPI stays Daytona-only (`SandboxProviderManifest`), matching main.
+ * Env-synthesized truefoundry records use `StoredSandboxProviderManifest` (store/runtime only).
*/
import { z } from '@hono/zod-openapi';
import type { DaytonaSandboxProviderOptions } from '@truefoundry/trueforge-core/core';
@@ -22,9 +25,6 @@ const DaytonaSandboxProviderAuthSchema = z
/**
* Daytona-backed sandbox provider config. Persisted as `sandbox_provider.manifest`.
- * Left unnamed for OpenAPI so `SandboxProviderManifest` (its single-variant alias)
- * is the one emitted component and the response `manifest` field is a plain `$ref`
- * instead of an `allOf` wrapper.
*/
export const DaytonaSandboxProviderSchema = z
.object({
@@ -48,13 +48,29 @@ export const DaytonaSandboxProviderSchema = z
.describe('Minutes before Daytona auto-deletes the sandbox (0 disables).'),
})
.strict();
+export const SandboxProviderManifestSchema = DaytonaSandboxProviderSchema.openapi('SandboxProviderManifest');
/**
- * Persisted jsonb: the provider config only (no build status). Single variant today —
- * this alias carries the OpenAPI name so the spec emits one `SandboxProviderManifest` component.
- * Widen to `z.discriminatedUnion('type', [...])` when a second provider ships.
+ * TrueFoundry (on-prem) sandbox config — env-synthesized store records only.
+ * Not registered in OpenAPI.
*/
-export const SandboxProviderManifestSchema = DaytonaSandboxProviderSchema.openapi('SandboxProviderManifest');
+export const TrueFoundrySandboxProviderSchema = z
+ .object({
+ type: z.literal('truefoundry').describe('TrueFoundry sandbox provider.'),
+ server_url: z.string().min(1).describe('TFY sandbox HTTP server URL.'),
+ nats_bridge_url: z.string().min(1).describe('Cluster-internal NATS WebSocket bridge URL.'),
+ exec_timeout_ms: z.number().int().positive().describe('Default sandbox command exec timeout in milliseconds.'),
+ })
+ .strict();
+
+/**
+ * Store / runtime jsonb: Daytona settings rows plus env-synthesized truefoundry.
+ * Not an OpenAPI component.
+ */
+export const StoredSandboxProviderManifestSchema = z.discriminatedUnion('type', [
+ DaytonaSandboxProviderSchema,
+ TrueFoundrySandboxProviderSchema,
+]);
/** Named enum so the generated SDK exposes a reusable `SandboxBuildStatus` type. */
export const SandboxBuildStatusSchema = z
@@ -78,7 +94,7 @@ export const SandboxStatusSchema = z
})
.strict();
-/** Settings wire item: nested manifest plus build status (no build_metadata). */
+/** Settings wire item: nested Daytona manifest plus build status (no build_metadata). */
export const ConfiguredSandboxProviderSchema = z
.object({
manifest: SandboxProviderManifestSchema,
@@ -101,9 +117,12 @@ export const GetSandboxProviderResponseSchema = z
})
.openapi('GetSandboxProviderResponse');
-/** Persisted jsonb — the provider config only (no build status). */
+/** Settings / OpenAPI — Daytona only. */
export type SandboxProviderManifest = z.infer<typeof SandboxProviderManifestSchema>;
export type DaytonaSandboxProvider = z.infer<typeof DaytonaSandboxProviderSchema>;
+/** Store/runtime jsonb — may be Daytona or env-synthesized truefoundry. */
+export type StoredSandboxProviderManifest = z.infer<typeof StoredSandboxProviderManifestSchema>;
+export type TrueFoundrySandboxProvider = z.infer<typeof TrueFoundrySandboxProviderSchema>;
export type SandboxBuildStatus = z.infer<typeof SandboxBuildStatusSchema>;
export type SandboxBuildMetadata = z.infer<typeof SandboxBuildMetadataSchema>;
export type SandboxStatus = z.infer<typeof SandboxStatusSchema>;
diff --git a/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts b/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts
index 3e0ad1381..e309f0e41 100644
--- a/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts
+++ b/packages/trueforge/src/truefoundry/TrueFoundrySandboxProviderStore.ts
@@ -1,116 +1,83 @@
-import { LRUCache } from 'lru-cache';
-import { z } from 'zod';
-import type { RequestContext } from '../auth/identity';
import type {
ISandboxProviderStore,
SandboxProviderRecord,
UpdateSandboxStatusInput,
UpsertSandboxProviderInput,
} from '../db/sandboxProviderStore';
-import { callerAccessToken, type ResolveAccessToken } from './accessToken';
import { trueFoundryManaged } from './errors';
-import { resolveTrueFoundrySandboxProviderConfig } from './resolveTrueFoundrySandboxProviderConfig';
+import {
+ resolveTrueFoundrySandboxProviderConfig,
+ SANDBOX_DEFAULT_SETTINGS,
+ type TrueFoundrySandboxProviderConfig,
+} from './resolveTrueFoundrySandboxProviderConfig';
-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,
-});
+function synthesizeDaytonaRecord({
+ tenantId,
+ providerConfig,
+}: {
+ tenantId: string;
+ providerConfig: Extract<TrueFoundrySandboxProviderConfig, { type: 'daytona' }>;
+}): SandboxProviderRecord {
+ const { settings } = providerConfig;
+ 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; TrueFoundry 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,
+ };
+}
-async function resolveDaytonaSandboxSettings({
- accessToken,
- settingsServerUrl,
+function synthesizeTrueFoundryRecord({
+ tenantId,
+ providerConfig,
}: {
- 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;
+ tenantId: string;
+ providerConfig: Extract<TrueFoundrySandboxProviderConfig, { type: 'truefoundry' }>;
+}): SandboxProviderRecord {
+ const now = new Date().toISOString();
+ return {
+ tenant_id: tenantId,
+ manifest: {
+ type: 'truefoundry',
+ server_url: providerConfig.serverUrl,
+ nats_bridge_url: providerConfig.natsBridgeUrl,
+ exec_timeout_ms: SANDBOX_DEFAULT_SETTINGS.timeoutMs,
+ },
+ status: 'ready',
+ status_reason: null,
+ build_metadata: null,
+ created_at: now,
+ updated_at: now,
+ };
}
+/** Env-backed shared sandbox; no per-request credentials (settings are static JSON). */
export class TrueFoundrySandboxProviderStore<TTransaction = never> implements ISandboxProviderStore<TTransaction> {
- readonly #resolveAccessToken: ResolveAccessToken;
-
- constructor(input: { context: RequestContext }) {
- this.#resolveAccessToken = callerAccessToken(input.context);
- }
-
- async getSandboxProvider(tenantId: string, transaction?: TTransaction): Promise<SandboxProviderRecord | undefined> {
+ getSandboxProvider(tenantId: string, transaction?: TTransaction): Promise<SandboxProviderRecord | undefined> {
void transaction;
const providerConfig = resolveTrueFoundrySandboxProviderConfig();
if (!providerConfig) {
- return undefined;
+ return Promise.resolve(undefined);
+ }
+ switch (providerConfig.type) {
+ case 'daytona':
+ return Promise.resolve(synthesizeDaytonaRecord({ tenantId, providerConfig }));
+ case 'truefoundry':
+ return Promise.resolve(synthesizeTrueFoundryRecord({ tenantId, providerConfig }));
}
- const settings = await resolveDaytonaSandboxSettings({
- accessToken: await this.#resolveAccessToken(),
- 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> {
diff --git a/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts b/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts
index 9fc42fb01..fd4c1d2b8 100644
--- a/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts
+++ b/packages/trueforge/src/truefoundry/resolveTrueFoundrySandboxProviderConfig.ts
@@ -1,18 +1,50 @@
import { HTTPException } from 'hono/http-exception';
+import { z } from 'zod';
import configuration, { type ServerConfiguration } from '../config';
+export const SANDBOX_DEFAULT_SETTINGS = {
+ timeoutMs: 60_000,
+ autoStopIntervalInMinutes: 5,
+ autoArchiveIntervalInMinutes: 60,
+ autoDeleteIntervalInMinutes: 43_200,
+} as const;
+
+/** Daytona settings JSON in `TRUEFOUNDRY_SANDBOX_SETTINGS`*/
+export 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),
+});
+
+export type DaytonaSandboxSettings = z.infer<typeof DaytonaSandboxSettingsSchema>;
+
+/** TrueFoundry on-prem settings JSON in `TRUEFOUNDRY_SANDBOX_SETTINGS`. */
+export const TrueFoundrySandboxSettingsSchema = z.object({
+ nats_bridge_url: z.string().min(1, 'nats_bridge_url is required'),
+});
+
+export type TrueFoundrySandboxSettings = z.infer<typeof TrueFoundrySandboxSettingsSchema>;
+
/**
* Shared sandbox provider selected by env in TrueFoundry mode.
- * Daytona today; add a `tfy` branch when `TFY_SANDBOX_SERVER_URL` ships.
+ * Settings come from static `TRUEFOUNDRY_SANDBOX_SETTINGS` JSON.
*/
-export interface TrueFoundrySandboxProviderConfig {
- type: 'daytona';
- apiKey: string;
- settingsServerUrl: string;
+export type TrueFoundrySandboxProviderConfig =
+ | { type: 'daytona'; apiKey: string; settings: DaytonaSandboxSettings }
+ | { type: 'truefoundry'; serverUrl: string; natsBridgeUrl: string };
+
+function parseSettingsJson(raw: string): unknown {
+ try {
+ return JSON.parse(raw);
+ } catch (error) {
+ throw new Error('TRUEFOUNDRY_SANDBOX_SETTINGS must be valid JSON', { cause: error });
+ }
}
/**
- * Returns the configured shared sandbox provider when Daytona env is complete, or undefined.
+ * Returns the configured shared sandbox provider when enabled, or undefined when disabled.
* Must only be called outside standalone (TrueFoundry wiring).
*/
export function resolveTrueFoundrySandboxProviderConfig(
@@ -23,16 +55,36 @@ export function resolveTrueFoundrySandboxProviderConfig(
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,
- };
+ if (!config.TRUEFOUNDRY_SANDBOX_ENABLED) {
+ return undefined;
+ }
+ if (config.TRUEFOUNDRY_SANDBOX_PROVIDER !== undefined && config.TRUEFOUNDRY_SANDBOX_SETTINGS !== undefined) {
+ const settingsJson = parseSettingsJson(config.TRUEFOUNDRY_SANDBOX_SETTINGS);
+ switch (config.TRUEFOUNDRY_SANDBOX_PROVIDER) {
+ case 'daytona': {
+ if (config.TRUEFOUNDRY_SANDBOX_API_KEY === undefined) {
+ throw new Error('TRUEFOUNDRY_SANDBOX_API_KEY is required when TRUEFOUNDRY_SANDBOX_PROVIDER is daytona');
+ }
+ return {
+ type: 'daytona',
+ apiKey: config.TRUEFOUNDRY_SANDBOX_API_KEY,
+ settings: DaytonaSandboxSettingsSchema.parse(settingsJson),
+ };
+ }
+ case 'truefoundry': {
+ if (config.TRUEFOUNDRY_SANDBOX_SERVER_URL === undefined) {
+ throw new Error(
+ 'TRUEFOUNDRY_SANDBOX_SERVER_URL is required when TRUEFOUNDRY_SANDBOX_PROVIDER is truefoundry',
+ );
+ }
+ const settings = TrueFoundrySandboxSettingsSchema.parse(settingsJson);
+ return {
+ type: 'truefoundry',
+ serverUrl: config.TRUEFOUNDRY_SANDBOX_SERVER_URL,
+ natsBridgeUrl: settings.nats_bridge_url,
+ };
+ }
+ }
}
return undefined;
}
diff --git a/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts b/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts
index 0217f83a0..56140983f 100644
--- a/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts
+++ b/packages/trueforge/tests/unit/apis/sandboxProviders.test.ts
@@ -138,6 +138,27 @@ describe('sandboxProviders router', () => {
expect(await response.json()).toEqual({ error: { message: 'No sandbox provider configured' } });
});
+ it('GET / returns 404 when only an env-managed truefoundry provider exists', async () => {
+ const { settingsRouter: router, sandboxProviderStore: store } = await createRouters();
+ await store.upsertSandboxProvider({
+ tenant_id: 'default',
+ manifest: {
+ type: 'truefoundry',
+ server_url: 'http://sandbox-server',
+ nats_bridge_url: 'ws://nats-bridge',
+ exec_timeout_ms: 60_000,
+ },
+ status: 'ready',
+ status_reason: null,
+ build_metadata: null,
+ });
+
+ const response = await router.request('/');
+ expect(response.status).toBe(404);
+ expect(await response.json()).toEqual({ error: { message: 'No sandbox provider configured' } });
+ expect(mockCheckStatus).not.toHaveBeenCalled();
+ });
+
it('PUT builds the image + upserts, GET returns redacted auth plus live image status', async () => {
const put = await settingsRouter.request('/', putInit(putBody));
expect(put.status).toBe(200);
@@ -266,7 +287,10 @@ describe('sandbox-provider secret redaction and strict PUT', () => {
});
const stored = await sandboxProviderStore.getSandboxProvider('default');
- expect(stored?.manifest.auth.api_key).toBe(rotatedKey);
+ expect(stored?.manifest.type).toBe('daytona');
+ if (stored?.manifest.type === 'daytona') {
+ expect(stored.manifest.auth.api_key).toBe(rotatedKey);
+ }
});
it('PUT update reuses persisted build_metadata (no image upgrade on re-save)', async () => {
diff --git a/packages/trueforge/tests/unit/config/config.test.ts b/packages/trueforge/tests/unit/config/config.test.ts
new file mode 100644
index 000000000..769af31ee
--- /dev/null
+++ b/packages/trueforge/tests/unit/config/config.test.ts
@@ -0,0 +1,108 @@
+import type { ServerConfiguration } from '../../../src/config';
+import { resolveTrueFoundrySandboxProviderConfig } from '../../../src/truefoundry/resolveTrueFoundrySandboxProviderConfig';
+
+/** Minimal distributed config slice for resolve tests (unused fields are irrelevant). */
+function distributed(overrides: {
+ TRUEFOUNDRY_SANDBOX_ENABLED?: boolean;
+ TRUEFOUNDRY_SANDBOX_PROVIDER?: 'daytona' | 'truefoundry';
+ TRUEFOUNDRY_SANDBOX_API_KEY?: string;
+ TRUEFOUNDRY_SANDBOX_SERVER_URL?: string;
+ TRUEFOUNDRY_SANDBOX_SETTINGS?: string;
+}): ServerConfiguration {
+ return {
+ STANDALONE: false,
+ TRUEFOUNDRY_SANDBOX_ENABLED: false,
+ TRUEFOUNDRY_SANDBOX_PROVIDER: undefined,
+ TRUEFOUNDRY_SANDBOX_API_KEY: undefined,
+ TRUEFOUNDRY_SANDBOX_SERVER_URL: undefined,
+ TRUEFOUNDRY_SANDBOX_SETTINGS: undefined,
+ ...overrides,
+ } as ServerConfiguration;
+}
+
+describe('resolveTrueFoundrySandboxProviderConfig', () => {
+ it('returns undefined when sandbox is disabled', () => {
+ expect(resolveTrueFoundrySandboxProviderConfig(distributed({}))).toBeUndefined();
+ });
+
+ it('returns daytona with parsed settings JSON', () => {
+ expect(
+ resolveTrueFoundrySandboxProviderConfig(
+ distributed({
+ TRUEFOUNDRY_SANDBOX_ENABLED: true,
+ TRUEFOUNDRY_SANDBOX_PROVIDER: 'daytona',
+ TRUEFOUNDRY_SANDBOX_API_KEY: 'dtn-key',
+ TRUEFOUNDRY_SANDBOX_SETTINGS: JSON.stringify({
+ snapshotName: 'snap-1',
+ timeoutMs: 90_000,
+ autoStopIntervalInMinutes: 10,
+ }),
+ }),
+ ),
+ ).toEqual({
+ type: 'daytona',
+ apiKey: 'dtn-key',
+ settings: {
+ snapshotName: 'snap-1',
+ timeoutMs: 90_000,
+ autoStopIntervalInMinutes: 10,
+ autoArchiveIntervalInMinutes: 60,
+ autoDeleteIntervalInMinutes: 43_200,
+ },
+ });
+ });
+
+ it('returns truefoundry with server URL and nats_bridge_url from settings', () => {
+ expect(
+ resolveTrueFoundrySandboxProviderConfig(
+ distributed({
+ TRUEFOUNDRY_SANDBOX_ENABLED: true,
+ TRUEFOUNDRY_SANDBOX_PROVIDER: 'truefoundry',
+ TRUEFOUNDRY_SANDBOX_SERVER_URL: 'http://sandbox-server',
+ TRUEFOUNDRY_SANDBOX_SETTINGS: JSON.stringify({ nats_bridge_url: 'ws://nats-bridge' }),
+ }),
+ ),
+ ).toEqual({
+ type: 'truefoundry',
+ serverUrl: 'http://sandbox-server',
+ natsBridgeUrl: 'ws://nats-bridge',
+ });
+ });
+
+ it('throws when daytona is enabled without API key', () => {
+ expect(() =>
+ resolveTrueFoundrySandboxProviderConfig(
+ distributed({
+ TRUEFOUNDRY_SANDBOX_ENABLED: true,
+ TRUEFOUNDRY_SANDBOX_PROVIDER: 'daytona',
+ TRUEFOUNDRY_SANDBOX_SETTINGS: JSON.stringify({ snapshotName: 'snap-1' }),
+ }),
+ ),
+ ).toThrow(/TRUEFOUNDRY_SANDBOX_API_KEY/);
+ });
+
+ it('throws when truefoundry is enabled without server URL', () => {
+ expect(() =>
+ resolveTrueFoundrySandboxProviderConfig(
+ distributed({
+ TRUEFOUNDRY_SANDBOX_ENABLED: true,
+ TRUEFOUNDRY_SANDBOX_PROVIDER: 'truefoundry',
+ TRUEFOUNDRY_SANDBOX_SETTINGS: JSON.stringify({ nats_bridge_url: 'ws://nats-bridge' }),
+ }),
+ ),
+ ).toThrow(/TRUEFOUNDRY_SANDBOX_SERVER_URL/);
+ });
+
+ it('throws when settings JSON is invalid', () => {
+ expect(() =>
+ resolveTrueFoundrySandboxProviderConfig(
+ distributed({
+ TRUEFOUNDRY_SANDBOX_ENABLED: true,
+ TRUEFOUNDRY_SANDBOX_PROVIDER: 'daytona',
+ TRUEFOUNDRY_SANDBOX_API_KEY: 'dtn-key',
+ TRUEFOUNDRY_SANDBOX_SETTINGS: '{not-json',
+ }),
+ ),
+ ).toThrow(/TRUEFOUNDRY_SANDBOX_SETTINGS must be valid JSON/);
+ });
+});
diff --git a/packages/trueforge/tests/unit/schemas/sandboxProvider.test.ts b/packages/trueforge/tests/unit/schemas/sandboxProvider.test.ts
index 39837ad1c..12a3a7412 100644
--- a/packages/trueforge/tests/unit/schemas/sandboxProvider.test.ts
+++ b/packages/trueforge/tests/unit/schemas/sandboxProvider.test.ts
@@ -1,4 +1,9 @@
-import { toDaytonaSandboxProviderInput, type SandboxProviderManifest } from '../../../src/schemas/sandboxProvider';
+import {
+ StoredSandboxProviderManifestSchema,
+ UpdateSandboxProviderRequestSchema,
+ toDaytonaSandboxProviderInput,
+ type SandboxProviderManifest,
+} from '../../../src/schemas/sandboxProvider';
describe('toDaytonaSandboxProviderInput', () => {
it('maps a Daytona wire/DB manifest to apiKey plus provider settings', () => {
@@ -20,3 +25,36 @@ describe('toDaytonaSandboxProviderInput', () => {
});
});
});
+
+describe('StoredSandboxProviderManifestSchema', () => {
+ it('parses a truefoundry manifest for internal store use', () => {
+ expect(
+ StoredSandboxProviderManifestSchema.parse({
+ type: 'truefoundry',
+ server_url: 'http://sandbox-server',
+ nats_bridge_url: 'ws://nats-bridge',
+ exec_timeout_ms: 60_000,
+ }),
+ ).toEqual({
+ type: 'truefoundry',
+ server_url: 'http://sandbox-server',
+ nats_bridge_url: 'ws://nats-bridge',
+ exec_timeout_ms: 60_000,
+ });
+ });
+});
+
+describe('UpdateSandboxProviderRequestSchema', () => {
+ it('rejects a truefoundry manifest (settings PUT is Daytona-only)', () => {
+ expect(() =>
+ UpdateSandboxProviderRequestSchema.parse({
+ manifest: {
+ type: 'truefoundry',
+ server_url: 'http://sandbox-server',
+ nats_bridge_url: 'ws://nats-bridge',
+ exec_timeout_ms: 60_000,
+ },
+ }),
+ ).toThrow();
+ });
+});
diff --git a/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts b/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts
index 684ca222e..55a699b20 100644
--- a/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts
+++ b/packages/trueforge/tests/unit/truefoundry/TrueFoundrySandboxProviderStore.test.ts
@@ -1,13 +1,12 @@
-import type { RequestContext } from '../../../src/auth/identity';
import { TRUEFOUNDRY_MANAGED_MESSAGE, TRUEFOUNDRY_MANAGED_STATUS } from '../../../src/truefoundry/errors';
import { resolveTrueFoundrySandboxProviderConfig } from '../../../src/truefoundry/resolveTrueFoundrySandboxProviderConfig';
import { TrueFoundrySandboxProviderStore } from '../../../src/truefoundry/TrueFoundrySandboxProviderStore';
jest.mock('../../../src/truefoundry/resolveTrueFoundrySandboxProviderConfig', () => {
- const resolveTrueFoundrySandboxProviderConfig = jest.fn();
+ const actual = jest.requireActual('../../../src/truefoundry/resolveTrueFoundrySandboxProviderConfig');
return {
- __esModule: true,
- resolveTrueFoundrySandboxProviderConfig,
+ ...actual,
+ resolveTrueFoundrySandboxProviderConfig: jest.fn(),
};
});
@@ -15,32 +14,14 @@ const mockResolveConfig = resolveTrueFoundrySandboxProviderConfig as jest.Mocked
typeof resolveTrueFoundrySandboxProviderConfig
>;
-const ACCESS_TOKEN = 'caller-token';
const TENANT = 'acme';
-const context: RequestContext = {
- tenant_id: TENANT,
- subject: { id: 'user-1', type: 'user', display_name: 'user-1' },
- roles: [],
- user_credential: ACCESS_TOKEN,
-};
-const SETTINGS_BODY = {
+const DAYTONA_SETTINGS = {
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;
-}
+} as const;
describe('TrueFoundrySandboxProviderStore', () => {
beforeEach(() => {
@@ -48,59 +29,63 @@ describe('TrueFoundrySandboxProviderStore', () => {
mockResolveConfig.mockReturnValue({
type: 'daytona',
apiKey: 'dtn-shared-key',
- settingsServerUrl: 'https://settings.example/daytona/settings',
+ settings: { ...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({ context });
+ const store = new TrueFoundrySandboxProviderStore();
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({ context });
+ it('get returns ready Daytona record from static settings', async () => {
+ const store = new TrueFoundrySandboxProviderStore();
+
+ const record = await store.getSandboxProvider(TENANT);
- await expect(store.getSandboxProvider(TENANT)).rejects.toThrow('Sandbox settings endpoint timed out after 10s');
+ expect(record).toMatchObject({
+ tenant_id: TENANT,
+ status: 'ready',
+ status_reason: null,
+ build_metadata: { build_ref: DAYTONA_SETTINGS.snapshotName },
+ manifest: {
+ type: 'daytona',
+ auth: { api_key: 'dtn-shared-key' },
+ exec_timeout_ms: DAYTONA_SETTINGS.timeoutMs,
+ auto_stop_interval_in_minutes: DAYTONA_SETTINGS.autoStopIntervalInMinutes,
+ auto_archive_interval_in_minutes: DAYTONA_SETTINGS.autoArchiveIntervalInMinutes,
+ auto_delete_interval_in_minutes: DAYTONA_SETTINGS.autoDeleteIntervalInMinutes,
+ },
+ });
});
- it('get returns ready Daytona record with snapshot build_ref from settings server', async () => {
- const fetchMock = mockSettingsFetch();
- const store = new TrueFoundrySandboxProviderStore({ context });
+ it('get returns ready truefoundry record from static settings', async () => {
+ mockResolveConfig.mockReturnValue({
+ type: 'truefoundry',
+ serverUrl: 'http://sandbox-server',
+ natsBridgeUrl: 'ws://nats-bridge',
+ });
+ const store = new TrueFoundrySandboxProviderStore();
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 },
+ build_metadata: null,
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,
+ type: 'truefoundry',
+ server_url: 'http://sandbox-server',
+ nats_bridge_url: 'ws://nats-bridge',
+ exec_timeout_ms: 60_000,
},
});
});
it('writes and get-for-update are managed (424)', () => {
- const store = new TrueFoundrySandboxProviderStore({ context });
+ const store = new TrueFoundrySandboxProviderStore();
const assertManaged = (run: () => unknown) => {
try {
run();
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9405b0a3f..4db699d6f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -165,9 +165,6 @@ 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
@@ -5880,10 +5877,6 @@ packages:
resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
- resolution: {integrity: sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==}
- engines: {node: 20 || >=22}
-
resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
@@ -13611,8 +13604,6 @@ snapshots:
-
dependencies:
yallist: 3.1.1