@mastra/factory 0.11.1 → 0.12.0-alpha.0

package/dist/sandbox/fleet.js

@@ -1,356 +0,0 @@
-import { timedPhase } from "../timing.js";
-import path from "path";
-//#region src/sandbox/fleet.ts
-/**
-* Project sandbox fleet: provisioning, reattach, teardown, and budgeting.
-*
-* Server-hosted projects never run on the web host itself. Each project gets
-* its own isolated sandbox (a `WorkspaceSandbox`, e.g. a Railway VM) `clone()`d
-* from the machine the factory was configured with. This module owns everything
-* about that fleet — which provider is active, where checkouts live inside a
-* sandbox, the idle window, the per-replica budget, and the
-* provision/reattach/teardown lifecycle — but knows nothing about what runs
-* inside a sandbox (git materialization lives with its feature, e.g. the
-* GitHub integration's `sandbox.ts`).
-*
-* The fleet is constructed once at boot with the machine config (or none, when
-* sandboxes are disabled) and handed to consumers — no global registry.
-* Persistence of the provider's reattach id is delegated to the caller via
-* {@link SandboxBindingStore}, so the fleet stays storage-agnostic. Tests can
-* swap the low-level construction via {@link SandboxFleet.setFactory}.
-*/
-/** Invoke a progress callback without letting it break the actual work. */
-function reportProgress(onProgress, event) {
-	if (!onProgress) return;
-	try {
-		onProgress(event);
-	} catch {}
-}
-/** Raised when provisioning would exceed the per-replica sandbox budget. */
-var SandboxBudgetError = class extends Error {
-	max;
-	code = "sandbox-budget-exceeded";
-	constructor(max) {
-		super(`Sandbox budget exceeded: this server already has ${max} active sandbox(es), the configured per-replica maximum. Close an existing repository's sandbox and try again.`);
-		this.max = max;
-		this.name = "SandboxBudgetError";
-	}
-};
-/**
-* Stable identity for one binding's in-flight provision work, used to coalesce
-* concurrent `ensureSandbox` calls. Prefer `checkpointName` — it is a pure
-* function of the owning session and is set before the first provision, which
-* is exactly when the herd forms (the stored `sandboxId` is still null then).
-* Fall back to the stored provider id, and skip coalescing entirely for
-* bindings with neither: keying those on a shared constant would wrongly
-* funnel *different* bindings onto one sandbox.
-*/
-function coalesceKey(store) {
-	if (store.checkpointName) return `checkpoint:${store.checkpointName}`;
-	if (store.sandboxId) return `sandbox:${store.sandboxId}`;
-}
-/**
-* Adapt a cloned `WorkspaceSandbox` to the minimal surface this module needs.
-* Lifecycle goes through the `_`-prefixed wrappers when present (they add
-* status tracking and concurrency safety on `MastraSandbox` subclasses),
-* falling back to the plain methods for interface-only implementations.
-*/
-function toMaterializationSandbox(sandbox, initialEnvironment = {}) {
-	if (typeof sandbox.executeCommand !== "function") throw new Error(`Sandbox provider '${sandbox.provider}' does not implement executeCommand() — cannot materialize repos.`);
-	const lifecycle = sandbox;
-	const environment = { ...initialEnvironment };
-	return {
-		id: sandbox.id,
-		name: sandbox.name,
-		provider: sandbox.provider,
-		getInstructions: (opts) => sandbox.getInstructions?.(opts) ?? "",
-		processes: sandbox.processes,
-		mounts: sandbox.mounts,
-		start: async () => {
-			await (lifecycle._start ?? sandbox.start)?.call(sandbox);
-		},
-		getInfo: async () => await sandbox.getInfo?.() ?? {},
-		executeCommand: (command, args, options) => sandbox.executeCommand(command, args, {
-			...options,
-			env: {
-				...environment,
-				...options?.env
-			}
-		}),
-		setEnvironmentVariable: (name, value) => {
-			environment[name] = value;
-		},
-		stop: async () => {
-			await (lifecycle._stop ?? sandbox.stop)?.call(sandbox);
-		},
-		supportsCheckpoints: sandbox.supportsCheckpoints === true,
-		...sandbox.snapshot ? { snapshot: sandbox.snapshot.bind(sandbox) } : {}
-	};
-}
-/**
-* Provider details reported after startup. Railway exposes its native sandbox
-* id and the checkpoint it actually restored through `getInfo().metadata`.
-*/
-async function readProviderSandboxDetails(sandbox) {
-	const info = await sandbox.getInfo();
-	const id = info.metadata?.railwaySandboxId ?? info.metadata?.sandboxId;
-	const restoredCheckpointName = info.metadata?.restoredCheckpointName;
-	return {
-		sandboxId: typeof id === "string" ? id : sandbox.id,
-		restoredCheckpointName: typeof restoredCheckpointName === "string" ? restoredCheckpointName : void 0
-	};
-}
-/** Keep each path piece a single safe segment (no separators or traversal). */
-function sanitizeSegment(segment) {
-	return segment.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^\.+/, "") || "repo";
-}
-/** Resolve a workdir under `root`, refusing any path that escapes the configured root. */
-function resolveContainedLocalWorkdir(root, ...segments) {
-	const resolvedRoot = path.resolve(root);
-	const resolved = path.resolve(resolvedRoot, ...segments);
-	if (resolved !== resolvedRoot && resolved.startsWith(`${resolvedRoot}${path.sep}`)) return resolved;
-	throw new Error(`Refusing to use local sandbox path outside configured root: ${resolved}`);
-}
-/**
-* The sandbox fleet for one deployment. Constructed once at boot — with a
-* config when a sandbox machine was configured, or without one when sandboxes
-* are disabled (every provisioning entry point then throws and
-* {@link enabled} reports `false` so features stay off).
-*/
-var SandboxFleet = class {
-	#config;
-	#factory;
-	#liveCount = 0;
-	/** In-flight `ensureSandbox` work, keyed per binding so concurrent callers coalesce. */
-	#inflight = /* @__PURE__ */ new Map();
-	constructor(config) {
-		this.#config = config;
-	}
-	/**
-	* True when a sandbox machine was configured. The factory validates the
-	* machine implements `clone()` at boot, so a configured fleet is usable —
-	* sandbox-backed projects stay off only when the slot was omitted.
-	*/
-	get enabled() {
-		return this.#config !== void 0;
-	}
-	/**
-	* Name of the active sandbox provider — the configured machine's `provider`
-	* discriminator (`'railway'`, `'local'`, …), or `'none'` when the fleet was
-	* constructed without a config. Diagnostic only; feature gating goes
-	* through {@link enabled}.
-	*/
-	get provider() {
-		return this.#config?.machine.provider ?? "none";
-	}
-	/**
-	* Usage instructions from the configured template machine, for surfacing in
-	* tool descriptions before any per-session sandbox has materialized.
-	* Empty string when no machine is configured or it exposes none.
-	*/
-	getInstructions() {
-		return this.#config?.machine.getInstructions?.() ?? "";
-	}
-	/**
-	* Idle teardown window for provisioned sandboxes, in minutes; defaults to 30.
-	* Read back from the machine's own config when it exposes one
-	* (Railway's `idleTimeoutMinutes`) — the knob lives on the sandbox, the
-	* fleet only needs it to schedule GC and stamp sandbox clones. Advisory:
-	* providers without idle GC ignore it, and a re-open detects a torn-down VM
-	* and re-provisions cleanly.
-	*/
-	get idleMinutes() {
-		const minutes = (this.#config?.machine)?.idleTimeoutMinutes;
-		return typeof minutes === "number" && Number.isFinite(minutes) && minutes > 0 ? minutes : 30;
-	}
-	/**
-	* Per-replica cap on concurrently *provisioned* sandboxes. 0 means unlimited.
-	* This is a lightweight per-process budget to keep a single replica from
-	* exhausting provider quota — it is not a global, cross-replica scheduler
-	* (that is a deferred follow-up).
-	*/
-	get maxSandboxes() {
-		return this.#config?.maxSandboxes ?? 0;
-	}
-	/**
-	* Count of sandboxes this fleet has freshly provisioned and not yet torn
-	* down. Reattaches to existing VMs do not count (they reuse an already-billed
-	* sandbox). Used to enforce {@link maxSandboxes}.
-	*/
-	get liveCount() {
-		return this.#liveCount;
-	}
-	/** For tests: reset the live-sandbox counter to a known state. */
-	__resetLiveCount(value = 0) {
-		this.#liveCount = value;
-	}
-	/** Override the sandbox factory (tests). */
-	setFactory(factory) {
-		this.#factory = factory;
-	}
-	/** Reset to the default machine-cloning factory. */
-	resetFactory() {
-		this.#factory = void 0;
-	}
-	/**
-	* Compute the in-sandbox working directory for a repo: a nested
-	* `<base>/<owner>/<name>` layout under the factory-resolved checkout base.
-	* Nesting keeps same-name repos apart (`acme/api` vs `other/api`) — cloud
-	* sandboxes are one-per-project so it's merely tidy there, but local
-	* checkouts share one host root where it prevents collisions. Server-side
-	* only; never derived from client input.
-	*/
-	computeWorkdir(repoFullName) {
-		if (!this.#config) throw new Error("No sandbox configured");
-		const [owner, name] = repoFullName.split("/", 2);
-		return `${this.#config.workdirBase}/${sanitizeSegment(owner || "unknown")}/${sanitizeSegment(name || "repo")}`;
-	}
-	/**
-	* Compute the host working directory for a local GitHub session checkout.
-	* This is server-derived only: repo pieces are sanitized and the trusted
-	* session id is kept as a single path segment under the configured local root.
-	*/
-	computeLocalSessionWorkdir(repoFullName, sessionId) {
-		if (!this.#config) throw new Error("No sandbox configured");
-		if (this.#config.machine.provider !== "local") throw new Error("Local session workdirs require the local sandbox provider");
-		const localRoot = this.#config.machine.workingDirectory;
-		if (typeof localRoot !== "string" || localRoot.length === 0) throw new Error("Local sandbox working directory is not configured");
-		const [owner, name] = repoFullName.split("/", 2);
-		return resolveContainedLocalWorkdir(localRoot, "github-sessions", sanitizeSegment(owner || "unknown"), sanitizeSegment(name || "repo"), sanitizeSegment(sessionId));
-	}
-	/**
-	* Build a (not-yet-started) sandbox: the test-provided factory when set,
-	* otherwise a per-project clone of the configured machine. The stored id is
-	* passed both as the logical `id` (providers that reattach by construction
-	* id, e.g. local) and as the provider-native `sandboxId` hint (Railway) so
-	* reattach works across the provider matrix.
-	*
-	* `env` is deliberately NOT forwarded to the provider clone: remote
-	* providers bake creation-time env into the VM for its whole lifetime
-	* (`POST /sandbox`), which would persist credentials like `GH_TOKEN` inside
-	* a VM that can outlive the session and be reused by another user via the
-	* sandbox pool. Instead the env lives only on the adapter, which merges it
-	* into every `executeCommand` — commands see the (refreshable) token, but
-	* the VM itself never stores it.
-	*/
-	#build(opts) {
-		if (this.#factory) return this.#factory(opts);
-		if (!this.#config) throw new Error("No sandbox configured");
-		return toMaterializationSandbox(this.#config.machine.clone({
-			...opts.providerSandboxId ? {
-				id: opts.providerSandboxId,
-				sandboxId: opts.providerSandboxId
-			} : {},
-			...opts.workingDirectory ? { workingDirectory: opts.workingDirectory } : {},
-			...opts.idleTimeoutMinutes !== void 0 ? { idleTimeoutMinutes: opts.idleTimeoutMinutes } : {},
-			...opts.checkpointName ? { checkpointName: opts.checkpointName } : {},
-			...opts.seedCheckpointName ? { seedCheckpointName: opts.seedCheckpointName } : {},
-			...opts.actingUserId ? { actingUserId: opts.actingUserId } : {}
-		}), opts.env);
-	}
-	async ensureSandbox(store, envOrProgress, progressOrOptions, maybeOptions = {}) {
-		const env = typeof envOrProgress === "function" ? void 0 : envOrProgress;
-		const onProgress = typeof envOrProgress === "function" ? envOrProgress : progressOrOptions;
-		const options = typeof envOrProgress === "function" ? progressOrOptions ?? {} : maybeOptions;
-		const key = coalesceKey(store);
-		if (!key) return this.#ensureSandboxUncoalesced(store, env, onProgress, options);
-		const existing = this.#inflight.get(key);
-		if (existing) return existing;
-		const promise = this.#ensureSandboxUncoalesced(store, env, onProgress, options).finally(() => {
-			if (this.#inflight.get(key) === promise) this.#inflight.delete(key);
-		});
-		this.#inflight.set(key, promise);
-		return promise;
-	}
-	/** The single provision/reattach attempt behind {@link ensureSandbox}. */
-	async #ensureSandboxUncoalesced(store, env, onProgress, options) {
-		const idleTimeoutMinutes = this.idleMinutes;
-		const checkpointName = store.checkpointName;
-		if (store.sandboxId) {
-			reportProgress(onProgress, {
-				phase: "reattaching",
-				message: "Reconnecting to your sandbox…"
-			});
-			const reattached = this.#build({
-				providerSandboxId: store.sandboxId,
-				idleTimeoutMinutes,
-				...checkpointName ? { checkpointName } : {},
-				...env ? { env } : {},
-				...options.workingDirectory ? { workingDirectory: options.workingDirectory } : {},
-				...options.actingUserId ? { actingUserId: options.actingUserId } : {}
-			});
-			try {
-				await timedPhase("sandbox.reattach", () => reattached.start());
-				reattached.seedCheckpointNameUsed = void 0;
-				return reattached;
-			} catch {
-				await store.setSandboxId(null);
-			}
-		}
-		const max = this.maxSandboxes;
-		if (max > 0 && this.#liveCount >= max) throw new SandboxBudgetError(max);
-		reportProgress(onProgress, {
-			phase: "provisioning",
-			message: "Provisioning a new sandbox…"
-		});
-		const sandbox = this.#build({
-			idleTimeoutMinutes,
-			...checkpointName ? { checkpointName } : {},
-			...store.seedCheckpointName ? { seedCheckpointName: store.seedCheckpointName } : {},
-			...env ? { env } : {},
-			...options.workingDirectory ? { workingDirectory: options.workingDirectory } : {},
-			...options.actingUserId ? { actingUserId: options.actingUserId } : {}
-		});
-		await timedPhase("sandbox.provision", () => sandbox.start());
-		this.#liveCount += 1;
-		try {
-			const provider = await readProviderSandboxDetails(sandbox);
-			if (provider.sandboxId) await store.setSandboxId(provider.sandboxId);
-			if (store.seedCheckpointName && provider.restoredCheckpointName === store.seedCheckpointName) sandbox.seedCheckpointNameUsed = store.seedCheckpointName;
-			return sandbox;
-		} catch (error) {
-			if (this.#liveCount > 0) this.#liveCount -= 1;
-			try {
-				await sandbox.stop?.();
-			} catch {}
-			throw error;
-		}
-	}
-	/**
-	* Tear down a sandbox binding: stop the live VM (best-effort) and clear the
-	* persisted state through the binding store so the next open re-provisions
-	* cleanly. Decrements the per-replica live-sandbox counter.
-	*
-	* @param store   the binding to tear down
-	* @param sandbox an already-reattached live sandbox to stop, when available
-	*/
-	async teardownSandbox(store, sandbox) {
-		if (sandbox?.stop) try {
-			await sandbox.stop();
-		} catch {}
-		if (store.sandboxId) {
-			if (this.#liveCount > 0) this.#liveCount -= 1;
-			await store.clear();
-		}
-	}
-	/**
-	* Reattach to an already-provisioned sandbox by its provider id and start it.
-	* Used by the workspace seam when opening a project that was already
-	* materialized (sandbox id + workdir carried on controller state), so no DB
-	* round-trip is needed.
-	*/
-	async reattachSandbox(providerSandboxId, options = {}) {
-		const sandbox = this.#build({
-			providerSandboxId,
-			idleTimeoutMinutes: this.idleMinutes,
-			...options.workingDirectory ? { workingDirectory: options.workingDirectory } : {},
-			...options.actingUserId ? { actingUserId: options.actingUserId } : {}
-		});
-		await sandbox.start();
-		return sandbox;
-	}
-};
-//#endregion
-export { SandboxBudgetError, SandboxFleet, reportProgress, resolveContainedLocalWorkdir };
-
-//# sourceMappingURL=fleet.js.map

package/dist/sandbox/fleet.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fleet.js","names":["#config","#inflight","#liveCount","#factory","#ensureSandboxUncoalesced","#build"],"sources":["../../src/sandbox/fleet.ts"],"sourcesContent":["/**\n * Project sandbox fleet: provisioning, reattach, teardown, and budgeting.\n *\n * Server-hosted projects never run on the web host itself. Each project gets\n * its own isolated sandbox (a `WorkspaceSandbox`, e.g. a Railway VM) `clone()`d\n * from the machine the factory was configured with. This module owns everything\n * about that fleet — which provider is active, where checkouts live inside a\n * sandbox, the idle window, the per-replica budget, and the\n * provision/reattach/teardown lifecycle — but knows nothing about what runs\n * inside a sandbox (git materialization lives with its feature, e.g. the\n * GitHub integration's `sandbox.ts`).\n *\n * The fleet is constructed once at boot with the machine config (or none, when\n * sandboxes are disabled) and handed to consumers — no global registry.\n * Persistence of the provider's reattach id is delegated to the caller via\n * {@link SandboxBindingStore}, so the fleet stays storage-agnostic. Tests can\n * swap the low-level construction via {@link SandboxFleet.setFactory}.\n */\n\nimport path from 'node:path';\n\nimport type { WorkspaceSandbox } from '@mastra/core/workspace';\n\nimport { timedPhase } from '../timing.js';\n\n/** Minimal command result shape sandbox consumers depend on. */\nexport interface SandboxCommandResult {\n  exitCode: number;\n  stdout: string;\n  stderr: string;\n}\n\n/**\n * Minimal live-sandbox surface fleet consumers need: an id, a way to start it,\n * a way to learn the provider's reattach id, and command execution.\n */\nexport interface MaterializationSandbox {\n  readonly id: string;\n  /** Human-readable provider name, forwarded from the underlying sandbox. */\n  readonly name?: string;\n  /** Provider type discriminator, forwarded from the underlying sandbox. */\n  readonly provider?: string;\n  /** Sandbox usage instructions surfaced in tool descriptions. */\n  getInstructions?(opts?: { requestContext?: unknown }): string;\n  /** Long-running process capability, when the provider supports it. */\n  readonly processes?: WorkspaceSandbox['processes'];\n  /** Mount capability, when the provider supports it. */\n  readonly mounts?: WorkspaceSandbox['mounts'];\n  start(): Promise<void>;\n  getInfo(): Promise<{ metadata?: Record<string, unknown> }>;\n  executeCommand(\n    command: string,\n    args?: string[],\n    options?: { timeout?: number; env?: Record<string, string | undefined> },\n  ): Promise<SandboxCommandResult>;\n  /** Update an environment variable for future commands in this sandbox. */\n  setEnvironmentVariable?(name: string, value: string): void;\n  /** Tear down the underlying VM. Optional: providers without it are no-ops. */\n  stop?(): Promise<void>;\n  /** True when the provider persists real checkpoints (snapshot is not a no-op). */\n  readonly supportsCheckpoints?: boolean;\n  /** Persist the sandbox's current state under its bound checkpoint name. */\n  snapshot?(): Promise<void>;\n  /** Boot-only fallback checkpoint requested for this fresh provision. */\n  seedCheckpointNameUsed?: string;\n}\n\n/** Options for building (or reattaching) one sandbox. */\nexport interface SandboxCreateOptions {\n  /** Reattach to this existing provider VM instead of provisioning a new one. */\n  providerSandboxId?: string;\n  /**\n   * Environment variables for commands run in the sandbox. Adapter-level\n   * only: merged into every `executeCommand`, never baked into the provider\n   * VM (see `SandboxFleet.#build`).\n   */\n  env?: Record<string, string>;\n  /** Provider working directory for this sandbox. */\n  workingDirectory?: string;\n  /** Idle teardown window (minutes). The provider stops the VM after this idle period. */\n  idleTimeoutMinutes?: number;\n  /** Provider checkpoint used to seed and preserve this sandbox's filesystem. */\n  checkpointName?: string;\n  /**\n   * Boot-only fallback checkpoint used when `checkpointName` has no stored\n   * state yet (e.g. the repo base checkpoint for a brand-new session).\n   * Snapshots keep writing to `checkpointName`.\n   */\n  seedCheckpointName?: string;\n  /** Opaque user subject attributed to provider API requests. */\n  actingUserId?: string;\n}\n\n/**\n * A coarse-grained step of the sandbox-preparation flow, reported as it happens\n * so the UI can show the user what the server is doing instead of a static\n * \"Preparing…\" toast. `phase` is a stable machine token; `message` is\n * user-facing copy.\n */\nexport interface PrepareProgress {\n  phase: 'reattaching' | 'provisioning' | 'preparing-workspace' | 'cloning' | 'pulling' | 'finalizing' | 'done';\n  message: string;\n}\n\n/** Callback invoked with each preparation step. Best-effort; never throws. */\nexport type ProgressFn = (event: PrepareProgress) => void;\n\n/** Invoke a progress callback without letting it break the actual work. */\nexport function reportProgress(onProgress: ProgressFn | undefined, event: PrepareProgress): void {\n  if (!onProgress) return;\n  try {\n    onProgress(event);\n  } catch {\n    // Progress reporting must never break the actual work.\n  }\n}\n\n/**\n * Factory that builds a (not-yet-started) sandbox. When `providerSandboxId` is\n * provided the sandbox should reattach to that existing VM instead of\n * provisioning a new one.\n */\nexport type SandboxFactory = (opts: SandboxCreateOptions) => MaterializationSandbox;\n\n/** Raised when provisioning would exceed the per-replica sandbox budget. */\nexport class SandboxBudgetError extends Error {\n  readonly code = 'sandbox-budget-exceeded' as const;\n  constructor(readonly max: number) {\n    super(\n      `Sandbox budget exceeded: this server already has ${max} active sandbox(es), ` +\n        `the configured per-replica maximum. Close an existing repository's sandbox and try again.`,\n    );\n    this.name = 'SandboxBudgetError';\n  }\n}\n\n/** Optional knobs for provisioning/reattaching one sandbox. */\nexport interface EnsureSandboxOptions {\n  /** Provider working directory for this sandbox. */\n  workingDirectory?: string;\n  /** Opaque user subject attributed to provider API requests. */\n  actingUserId?: string;\n}\n\n/**\n * Where a feature persists its sandbox binding. The fleet reads the stored\n * reattach id and writes updates through this seam so it stays agnostic of\n * the owning table (GitHub projects today, anything else tomorrow).\n */\nexport interface SandboxBindingStore {\n  /** Stored provider reattach id from a previous provisioning, if any. */\n  readonly sandboxId: string | null;\n  /** Provider checkpoint used to seed and preserve this sandbox's filesystem. */\n  readonly checkpointName?: string;\n  /** Boot-only fallback checkpoint (e.g. repo base checkpoint) for first provision. */\n  readonly seedCheckpointName?: string;\n  /** Persist a freshly provisioned provider id, or clear a stale one with `null`. */\n  setSandboxId(id: string | null): Promise<void>;\n  /** Clear all stored sandbox state (reattach id + materialization mark) on teardown. */\n  clear(): Promise<void>;\n}\n\n/**\n * Stable identity for one binding's in-flight provision work, used to coalesce\n * concurrent `ensureSandbox` calls. Prefer `checkpointName` — it is a pure\n * function of the owning session and is set before the first provision, which\n * is exactly when the herd forms (the stored `sandboxId` is still null then).\n * Fall back to the stored provider id, and skip coalescing entirely for\n * bindings with neither: keying those on a shared constant would wrongly\n * funnel *different* bindings onto one sandbox.\n */\nfunction coalesceKey(store: SandboxBindingStore): string | undefined {\n  if (store.checkpointName) return `checkpoint:${store.checkpointName}`;\n  if (store.sandboxId) return `sandbox:${store.sandboxId}`;\n  return undefined;\n}\n\n/**\n * Adapt a cloned `WorkspaceSandbox` to the minimal surface this module needs.\n * Lifecycle goes through the `_`-prefixed wrappers when present (they add\n * status tracking and concurrency safety on `MastraSandbox` subclasses),\n * falling back to the plain methods for interface-only implementations.\n */\nfunction toMaterializationSandbox(\n  sandbox: WorkspaceSandbox,\n  initialEnvironment: Record<string, string> = {},\n): MaterializationSandbox {\n  if (typeof sandbox.executeCommand !== 'function') {\n    throw new Error(\n      `Sandbox provider '${sandbox.provider}' does not implement executeCommand() — cannot materialize repos.`,\n    );\n  }\n  const lifecycle = sandbox as { _start?(): Promise<void>; _stop?(): Promise<void> };\n  const environment = { ...initialEnvironment };\n  return {\n    id: sandbox.id,\n    name: sandbox.name,\n    provider: sandbox.provider,\n    getInstructions: opts =>\n      sandbox.getInstructions?.(opts as Parameters<NonNullable<WorkspaceSandbox['getInstructions']>>[0]) ?? '',\n    processes: sandbox.processes,\n    mounts: sandbox.mounts,\n    start: async () => {\n      await (lifecycle._start ?? sandbox.start)?.call(sandbox);\n    },\n    getInfo: async () => (await sandbox.getInfo?.()) ?? {},\n    executeCommand: (command, args, options) =>\n      sandbox.executeCommand!(command, args, {\n        ...options,\n        env: { ...environment, ...options?.env },\n      }),\n    setEnvironmentVariable: (name, value) => {\n      environment[name] = value;\n    },\n    stop: async () => {\n      await (lifecycle._stop ?? sandbox.stop)?.call(sandbox);\n    },\n    supportsCheckpoints: sandbox.supportsCheckpoints === true,\n    ...(sandbox.snapshot ? { snapshot: sandbox.snapshot.bind(sandbox) } : {}),\n  };\n}\n\n/**\n * Provider details reported after startup. Railway exposes its native sandbox\n * id and the checkpoint it actually restored through `getInfo().metadata`.\n */\nasync function readProviderSandboxDetails(\n  sandbox: MaterializationSandbox,\n): Promise<{ sandboxId: string | undefined; restoredCheckpointName: string | undefined }> {\n  const info = await sandbox.getInfo();\n  const id = info.metadata?.railwaySandboxId ?? info.metadata?.sandboxId;\n  const restoredCheckpointName = info.metadata?.restoredCheckpointName;\n  return {\n    sandboxId: typeof id === 'string' ? id : sandbox.id,\n    restoredCheckpointName: typeof restoredCheckpointName === 'string' ? restoredCheckpointName : undefined,\n  };\n}\n\n/** Keep each path piece a single safe segment (no separators or traversal). */\nfunction sanitizeSegment(segment: string): string {\n  const cleaned = segment.replace(/[^A-Za-z0-9._-]/g, '-').replace(/^\\.+/, '');\n  return cleaned || 'repo';\n}\n\n/** Resolve a workdir under `root`, refusing any path that escapes the configured root. */\nexport function resolveContainedLocalWorkdir(root: string, ...segments: string[]): string {\n  const resolvedRoot = path.resolve(root);\n  const resolved = path.resolve(resolvedRoot, ...segments);\n  if (resolved !== resolvedRoot && resolved.startsWith(`${resolvedRoot}${path.sep}`)) return resolved;\n  throw new Error(`Refusing to use local sandbox path outside configured root: ${resolved}`);\n}\n\n/**\n * Factory-resolved sandbox runtime the fleet is constructed with: the machine\n * projects clone their per-project sandboxes from, plus the knobs the factory\n * resolved around it.\n */\nexport interface SandboxFleetConfig {\n  /**\n   * Template machine (validated by the factory to implement `clone()`).\n   * Never started — acts purely as the credential/default holder that\n   * per-project sandboxes are cloned from.\n   */\n  machine: WorkspaceSandbox;\n  /** In-sandbox base directory repos check out under (no trailing slash). */\n  workdirBase: string;\n  /** Per-replica cap on concurrently provisioned sandboxes. 0 = unlimited. */\n  maxSandboxes?: number;\n}\n\n/**\n * The sandbox fleet for one deployment. Constructed once at boot — with a\n * config when a sandbox machine was configured, or without one when sandboxes\n * are disabled (every provisioning entry point then throws and\n * {@link enabled} reports `false` so features stay off).\n */\nexport class SandboxFleet {\n  readonly #config: SandboxFleetConfig | undefined;\n  #factory: SandboxFactory | undefined;\n  #liveCount = 0;\n  /** In-flight `ensureSandbox` work, keyed per binding so concurrent callers coalesce. */\n  readonly #inflight = new Map<string, Promise<MaterializationSandbox>>();\n\n  constructor(config?: SandboxFleetConfig) {\n    this.#config = config;\n  }\n\n  /**\n   * True when a sandbox machine was configured. The factory validates the\n   * machine implements `clone()` at boot, so a configured fleet is usable —\n   * sandbox-backed projects stay off only when the slot was omitted.\n   */\n  get enabled(): boolean {\n    return this.#config !== undefined;\n  }\n\n  /**\n   * Name of the active sandbox provider — the configured machine's `provider`\n   * discriminator (`'railway'`, `'local'`, …), or `'none'` when the fleet was\n   * constructed without a config. Diagnostic only; feature gating goes\n   * through {@link enabled}.\n   */\n  get provider(): string {\n    return this.#config?.machine.provider ?? 'none';\n  }\n\n  /**\n   * Usage instructions from the configured template machine, for surfacing in\n   * tool descriptions before any per-session sandbox has materialized.\n   * Empty string when no machine is configured or it exposes none.\n   */\n  getInstructions(): string {\n    return this.#config?.machine.getInstructions?.() ?? '';\n  }\n\n  /**\n   * Idle teardown window for provisioned sandboxes, in minutes; defaults to 30.\n   * Read back from the machine's own config when it exposes one\n   * (Railway's `idleTimeoutMinutes`) — the knob lives on the sandbox, the\n   * fleet only needs it to schedule GC and stamp sandbox clones. Advisory:\n   * providers without idle GC ignore it, and a re-open detects a torn-down VM\n   * and re-provisions cleanly.\n   */\n  get idleMinutes(): number {\n    const machine = this.#config?.machine as { idleTimeoutMinutes?: unknown } | undefined;\n    const minutes = machine?.idleTimeoutMinutes;\n    return typeof minutes === 'number' && Number.isFinite(minutes) && minutes > 0 ? minutes : 30;\n  }\n\n  /**\n   * Per-replica cap on concurrently *provisioned* sandboxes. 0 means unlimited.\n   * This is a lightweight per-process budget to keep a single replica from\n   * exhausting provider quota — it is not a global, cross-replica scheduler\n   * (that is a deferred follow-up).\n   */\n  get maxSandboxes(): number {\n    return this.#config?.maxSandboxes ?? 0;\n  }\n\n  /**\n   * Count of sandboxes this fleet has freshly provisioned and not yet torn\n   * down. Reattaches to existing VMs do not count (they reuse an already-billed\n   * sandbox). Used to enforce {@link maxSandboxes}.\n   */\n  get liveCount(): number {\n    return this.#liveCount;\n  }\n\n  /** For tests: reset the live-sandbox counter to a known state. */\n  __resetLiveCount(value = 0): void {\n    this.#liveCount = value;\n  }\n\n  /** Override the sandbox factory (tests). */\n  setFactory(factory: SandboxFactory): void {\n    this.#factory = factory;\n  }\n\n  /** Reset to the default machine-cloning factory. */\n  resetFactory(): void {\n    this.#factory = undefined;\n  }\n\n  /**\n   * Compute the in-sandbox working directory for a repo: a nested\n   * `<base>/<owner>/<name>` layout under the factory-resolved checkout base.\n   * Nesting keeps same-name repos apart (`acme/api` vs `other/api`) — cloud\n   * sandboxes are one-per-project so it's merely tidy there, but local\n   * checkouts share one host root where it prevents collisions. Server-side\n   * only; never derived from client input.\n   */\n  computeWorkdir(repoFullName: string): string {\n    if (!this.#config) throw new Error('No sandbox configured');\n    const [owner, name] = repoFullName.split('/', 2);\n    return `${this.#config.workdirBase}/${sanitizeSegment(owner || 'unknown')}/${sanitizeSegment(name || 'repo')}`;\n  }\n\n  /**\n   * Compute the host working directory for a local GitHub session checkout.\n   * This is server-derived only: repo pieces are sanitized and the trusted\n   * session id is kept as a single path segment under the configured local root.\n   */\n  computeLocalSessionWorkdir(repoFullName: string, sessionId: string): string {\n    if (!this.#config) throw new Error('No sandbox configured');\n    if (this.#config.machine.provider !== 'local') {\n      throw new Error('Local session workdirs require the local sandbox provider');\n    }\n\n    const localRoot = (this.#config.machine as { workingDirectory?: unknown }).workingDirectory;\n    if (typeof localRoot !== 'string' || localRoot.length === 0) {\n      throw new Error('Local sandbox working directory is not configured');\n    }\n\n    const [owner, name] = repoFullName.split('/', 2);\n    return resolveContainedLocalWorkdir(\n      localRoot,\n      'github-sessions',\n      sanitizeSegment(owner || 'unknown'),\n      sanitizeSegment(name || 'repo'),\n      sanitizeSegment(sessionId),\n    );\n  }\n\n  /**\n   * Build a (not-yet-started) sandbox: the test-provided factory when set,\n   * otherwise a per-project clone of the configured machine. The stored id is\n   * passed both as the logical `id` (providers that reattach by construction\n   * id, e.g. local) and as the provider-native `sandboxId` hint (Railway) so\n   * reattach works across the provider matrix.\n   *\n   * `env` is deliberately NOT forwarded to the provider clone: remote\n   * providers bake creation-time env into the VM for its whole lifetime\n   * (`POST /sandbox`), which would persist credentials like `GH_TOKEN` inside\n   * a VM that can outlive the session and be reused by another user via the\n   * sandbox pool. Instead the env lives only on the adapter, which merges it\n   * into every `executeCommand` — commands see the (refreshable) token, but\n   * the VM itself never stores it.\n   */\n  #build(opts: SandboxCreateOptions): MaterializationSandbox {\n    if (this.#factory) return this.#factory(opts);\n    if (!this.#config) throw new Error('No sandbox configured');\n    const clone = this.#config.machine.clone!({\n      ...(opts.providerSandboxId ? { id: opts.providerSandboxId, sandboxId: opts.providerSandboxId } : {}),\n      ...(opts.workingDirectory ? { workingDirectory: opts.workingDirectory } : {}),\n      ...(opts.idleTimeoutMinutes !== undefined ? { idleTimeoutMinutes: opts.idleTimeoutMinutes } : {}),\n      ...(opts.checkpointName ? { checkpointName: opts.checkpointName } : {}),\n      ...(opts.seedCheckpointName ? { seedCheckpointName: opts.seedCheckpointName } : {}),\n      ...(opts.actingUserId ? { actingUserId: opts.actingUserId } : {}),\n    });\n    return toMaterializationSandbox(clone, opts.env);\n  }\n\n  /**\n   * Provision a new sandbox (persisting its provider id on first open) or\n   * reattach to the stored one. Returns a started, live sandbox.\n   *\n   * Concurrent calls for the same binding coalesce onto one in-flight\n   * provision/reattach and share its sandbox handle — N simultaneous requests\n   * for one cold session (e.g. several browser tabs polling right after boot)\n   * must not each fire their own `POST /sandbox` against the provider.\n   * Failures are not cached: once the shared attempt settles, the next call\n   * starts fresh.\n   */\n  async ensureSandbox(store: SandboxBindingStore, onProgress?: ProgressFn): Promise<MaterializationSandbox>;\n  async ensureSandbox(\n    store: SandboxBindingStore,\n    env?: Record<string, string>,\n    onProgress?: ProgressFn,\n    options?: EnsureSandboxOptions,\n  ): Promise<MaterializationSandbox>;\n  async ensureSandbox(\n    store: SandboxBindingStore,\n    envOrProgress?: Record<string, string> | ProgressFn,\n    progressOrOptions?: ProgressFn | EnsureSandboxOptions,\n    maybeOptions: EnsureSandboxOptions = {},\n  ): Promise<MaterializationSandbox> {\n    const env = typeof envOrProgress === 'function' ? undefined : envOrProgress;\n    const onProgress =\n      typeof envOrProgress === 'function' ? envOrProgress : (progressOrOptions as ProgressFn | undefined);\n    const options =\n      typeof envOrProgress === 'function'\n        ? ((progressOrOptions as EnsureSandboxOptions | undefined) ?? {})\n        : maybeOptions;\n\n    const key = coalesceKey(store);\n    if (!key) return this.#ensureSandboxUncoalesced(store, env, onProgress, options);\n\n    const existing = this.#inflight.get(key);\n    if (existing) return existing;\n\n    const promise = this.#ensureSandboxUncoalesced(store, env, onProgress, options).finally(() => {\n      // Only clear when this is still the entry we own.\n      if (this.#inflight.get(key) === promise) this.#inflight.delete(key);\n    });\n    this.#inflight.set(key, promise);\n    return promise;\n  }\n\n  /** The single provision/reattach attempt behind {@link ensureSandbox}. */\n  async #ensureSandboxUncoalesced(\n    store: SandboxBindingStore,\n    env: Record<string, string> | undefined,\n    onProgress: ProgressFn | undefined,\n    options: EnsureSandboxOptions,\n  ): Promise<MaterializationSandbox> {\n    const idleTimeoutMinutes = this.idleMinutes;\n    const checkpointName = store.checkpointName;\n\n    // Reattach path: if we have a stored sandbox id, try to reattach. The VM may\n    // have been torn down by the provider's idle GC (or otherwise died), in which\n    // case `start()` fails. Recover by clearing the stale id and provisioning a\n    // fresh sandbox so the next open succeeds instead of being permanently wedged.\n    if (store.sandboxId) {\n      reportProgress(onProgress, { phase: 'reattaching', message: 'Reconnecting to your sandbox…' });\n      const reattached = this.#build({\n        providerSandboxId: store.sandboxId,\n        idleTimeoutMinutes,\n        ...(checkpointName ? { checkpointName } : {}),\n        ...(env ? { env } : {}),\n        ...(options.workingDirectory ? { workingDirectory: options.workingDirectory } : {}),\n        ...(options.actingUserId ? { actingUserId: options.actingUserId } : {}),\n      });\n      try {\n        await timedPhase('sandbox.reattach', () => reattached.start());\n        reattached.seedCheckpointNameUsed = undefined;\n        return reattached;\n      } catch {\n        await store.setSandboxId(null);\n        // fall through to fresh provision below\n      }\n    }\n\n    // Fresh provision: enforce the per-replica budget before spending quota.\n    const max = this.maxSandboxes;\n    if (max > 0 && this.#liveCount >= max) {\n      throw new SandboxBudgetError(max);\n    }\n\n    reportProgress(onProgress, { phase: 'provisioning', message: 'Provisioning a new sandbox…' });\n    const sandbox = this.#build({\n      idleTimeoutMinutes,\n      ...(checkpointName ? { checkpointName } : {}),\n      // Boot-only fallback seed (repo base checkpoint) — only meaningful on a\n      // fresh provision; snapshots keep writing to `checkpointName`.\n      ...(store.seedCheckpointName ? { seedCheckpointName: store.seedCheckpointName } : {}),\n      ...(env ? { env } : {}),\n      ...(options.workingDirectory ? { workingDirectory: options.workingDirectory } : {}),\n      ...(options.actingUserId ? { actingUserId: options.actingUserId } : {}),\n    });\n    await timedPhase('sandbox.provision', () => sandbox.start());\n    this.#liveCount += 1;\n\n    try {\n      const provider = await readProviderSandboxDetails(sandbox);\n      if (provider.sandboxId) {\n        await store.setSandboxId(provider.sandboxId);\n      }\n\n      if (store.seedCheckpointName && provider.restoredCheckpointName === store.seedCheckpointName) {\n        sandbox.seedCheckpointNameUsed = store.seedCheckpointName;\n      }\n      return sandbox;\n    } catch (error) {\n      if (this.#liveCount > 0) this.#liveCount -= 1;\n      try {\n        await sandbox.stop?.();\n      } catch {\n        // Preserve the provider-detail or persistence error that made the sandbox unusable.\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Tear down a sandbox binding: stop the live VM (best-effort) and clear the\n   * persisted state through the binding store so the next open re-provisions\n   * cleanly. Decrements the per-replica live-sandbox counter.\n   *\n   * @param store   the binding to tear down\n   * @param sandbox an already-reattached live sandbox to stop, when available\n   */\n  async teardownSandbox(store: SandboxBindingStore, sandbox?: MaterializationSandbox): Promise<void> {\n    if (sandbox?.stop) {\n      try {\n        await sandbox.stop();\n      } catch {\n        // Best-effort: the VM may already be gone (idle GC). Still clear the binding.\n      }\n    }\n    if (store.sandboxId) {\n      if (this.#liveCount > 0) this.#liveCount -= 1;\n      await store.clear();\n    }\n  }\n\n  /**\n   * Reattach to an already-provisioned sandbox by its provider id and start it.\n   * Used by the workspace seam when opening a project that was already\n   * materialized (sandbox id + workdir carried on controller state), so no DB\n   * round-trip is needed.\n   */\n  async reattachSandbox(\n    providerSandboxId: string,\n    options: EnsureSandboxOptions = {},\n  ): Promise<MaterializationSandbox> {\n    const sandbox = this.#build({\n      providerSandboxId,\n      idleTimeoutMinutes: this.idleMinutes,\n      ...(options.workingDirectory ? { workingDirectory: options.workingDirectory } : {}),\n      ...(options.actingUserId ? { actingUserId: options.actingUserId } : {}),\n    });\n    await sandbox.start();\n    return sandbox;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA4GA,SAAgB,eAAe,YAAoC,OAA8B;CAC/F,IAAI,CAAC,YAAY;CACjB,IAAI;EACF,WAAW,KAAK;CAClB,QAAQ,CAER;AACF;;AAUA,IAAa,qBAAb,cAAwC,MAAM;CAEvB;CADrB,OAAgB;CAChB,YAAY,KAAsB;EAChC,MACE,oDAAoD,IAAI,+GAE1D;EAJmB,KAAA,MAAA;EAKnB,KAAK,OAAO;CACd;AACF;;;;;;;;;;AAqCA,SAAS,YAAY,OAAgD;CACnE,IAAI,MAAM,gBAAgB,OAAO,cAAc,MAAM;CACrD,IAAI,MAAM,WAAW,OAAO,WAAW,MAAM;AAE/C;;;;;;;AAQA,SAAS,yBACP,SACA,qBAA6C,CAAC,GACtB;CACxB,IAAI,OAAO,QAAQ,mBAAmB,YACpC,MAAM,IAAI,MACR,qBAAqB,QAAQ,SAAS,kEACxC;CAEF,MAAM,YAAY;CAClB,MAAM,cAAc,EAAE,GAAG,mBAAmB;CAC5C,OAAO;EACL,IAAI,QAAQ;EACZ,MAAM,QAAQ;EACd,UAAU,QAAQ;EAClB,kBAAiB,SACf,QAAQ,kBAAkB,IAAuE,KAAK;EACxG,WAAW,QAAQ;EACnB,QAAQ,QAAQ;EAChB,OAAO,YAAY;GACjB,OAAO,UAAU,UAAU,QAAQ,MAAA,EAAQ,KAAK,OAAO;EACzD;EACA,SAAS,YAAa,MAAM,QAAQ,UAAU,KAAM,CAAC;EACrD,iBAAiB,SAAS,MAAM,YAC9B,QAAQ,eAAgB,SAAS,MAAM;GACrC,GAAG;GACH,KAAK;IAAE,GAAG;IAAa,GAAG,SAAS;GAAI;EACzC,CAAC;EACH,yBAAyB,MAAM,UAAU;GACvC,YAAY,QAAQ;EACtB;EACA,MAAM,YAAY;GAChB,OAAO,UAAU,SAAS,QAAQ,KAAA,EAAO,KAAK,OAAO;EACvD;EACA,qBAAqB,QAAQ,wBAAwB;EACrD,GAAI,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,KAAK,OAAO,EAAE,IAAI,CAAC;CACzE;AACF;;;;;AAMA,eAAe,2BACb,SACwF;CACxF,MAAM,OAAO,MAAM,QAAQ,QAAQ;CACnC,MAAM,KAAK,KAAK,UAAU,oBAAoB,KAAK,UAAU;CAC7D,MAAM,yBAAyB,KAAK,UAAU;CAC9C,OAAO;EACL,WAAW,OAAO,OAAO,WAAW,KAAK,QAAQ;EACjD,wBAAwB,OAAO,2BAA2B,WAAW,yBAAyB,KAAA;CAChG;AACF;;AAGA,SAAS,gBAAgB,SAAyB;CAEhD,OADgB,QAAQ,QAAQ,oBAAoB,GAAG,CAAC,CAAC,QAAQ,QAAQ,EAC5D,KAAK;AACpB;;AAGA,SAAgB,6BAA6B,MAAc,GAAG,UAA4B;CACxF,MAAM,eAAe,KAAK,QAAQ,IAAI;CACtC,MAAM,WAAW,KAAK,QAAQ,cAAc,GAAG,QAAQ;CACvD,IAAI,aAAa,gBAAgB,SAAS,WAAW,GAAG,eAAe,KAAK,KAAK,GAAG,OAAO;CAC3F,MAAM,IAAI,MAAM,+DAA+D,UAAU;AAC3F;;;;;;;AA0BA,IAAa,eAAb,MAA0B;CACxB;CACA;CACA,aAAa;;CAEb,4BAAqB,IAAI,IAA6C;CAEtE,YAAY,QAA6B;EACvC,KAAKA,UAAU;CACjB;;;;;;CAOA,IAAI,UAAmB;EACrB,OAAO,KAAKA,YAAY,KAAA;CAC1B;;;;;;;CAQA,IAAI,WAAmB;EACrB,OAAO,KAAKA,SAAS,QAAQ,YAAY;CAC3C;;;;;;CAOA,kBAA0B;EACxB,OAAO,KAAKA,SAAS,QAAQ,kBAAkB,KAAK;CACtD;;;;;;;;;CAUA,IAAI,cAAsB;EAExB,MAAM,WADU,KAAKA,SAAS,QAAA,EACL;EACzB,OAAO,OAAO,YAAY,YAAY,OAAO,SAAS,OAAO,KAAK,UAAU,IAAI,UAAU;CAC5F;;;;;;;CAQA,IAAI,eAAuB;EACzB,OAAO,KAAKA,SAAS,gBAAgB;CACvC;;;;;;CAOA,IAAI,YAAoB;EACtB,OAAO,KAAKE;CACd;;CAGA,iBAAiB,QAAQ,GAAS;EAChC,KAAKA,aAAa;CACpB;;CAGA,WAAW,SAA+B;EACxC,KAAKC,WAAW;CAClB;;CAGA,eAAqB;EACnB,KAAKA,WAAW,KAAA;CAClB;;;;;;;;;CAUA,eAAe,cAA8B;EAC3C,IAAI,CAAC,KAAKH,SAAS,MAAM,IAAI,MAAM,uBAAuB;EAC1D,MAAM,CAAC,OAAO,QAAQ,aAAa,MAAM,KAAK,CAAC;EAC/C,OAAO,GAAG,KAAKA,QAAQ,YAAY,GAAG,gBAAgB,SAAS,SAAS,EAAE,GAAG,gBAAgB,QAAQ,MAAM;CAC7G;;;;;;CAOA,2BAA2B,cAAsB,WAA2B;EAC1E,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,uBAAuB;EAC1D,IAAI,KAAKA,QAAQ,QAAQ,aAAa,SACpC,MAAM,IAAI,MAAM,2DAA2D;EAG7E,MAAM,YAAa,KAAKA,QAAQ,QAA2C;EAC3E,IAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GACxD,MAAM,IAAI,MAAM,mDAAmD;EAGrE,MAAM,CAAC,OAAO,QAAQ,aAAa,MAAM,KAAK,CAAC;EAC/C,OAAO,6BACL,WACA,mBACA,gBAAgB,SAAS,SAAS,GAClC,gBAAgB,QAAQ,MAAM,GAC9B,gBAAgB,SAAS,CAC3B;CACF;;;;;;;;;;;;;;;;CAiBA,OAAO,MAAoD;EACzD,IAAI,KAAKG,UAAU,OAAO,KAAKA,SAAS,IAAI;EAC5C,IAAI,CAAC,KAAKH,SAAS,MAAM,IAAI,MAAM,uBAAuB;EAS1D,OAAO,yBARO,KAAKA,QAAQ,QAAQ,MAAO;GACxC,GAAI,KAAK,oBAAoB;IAAE,IAAI,KAAK;IAAmB,WAAW,KAAK;GAAkB,IAAI,CAAC;GAClG,GAAI,KAAK,mBAAmB,EAAE,kBAAkB,KAAK,iBAAiB,IAAI,CAAC;GAC3E,GAAI,KAAK,uBAAuB,KAAA,IAAY,EAAE,oBAAoB,KAAK,mBAAmB,IAAI,CAAC;GAC/F,GAAI,KAAK,iBAAiB,EAAE,gBAAgB,KAAK,eAAe,IAAI,CAAC;GACrE,GAAI,KAAK,qBAAqB,EAAE,oBAAoB,KAAK,mBAAmB,IAAI,CAAC;GACjF,GAAI,KAAK,eAAe,EAAE,cAAc,KAAK,aAAa,IAAI,CAAC;EACjE,CACoC,GAAG,KAAK,GAAG;CACjD;CAoBA,MAAM,cACJ,OACA,eACA,mBACA,eAAqC,CAAC,GACL;EACjC,MAAM,MAAM,OAAO,kBAAkB,aAAa,KAAA,IAAY;EAC9D,MAAM,aACJ,OAAO,kBAAkB,aAAa,gBAAiB;EACzD,MAAM,UACJ,OAAO,kBAAkB,aACnB,qBAA0D,CAAC,IAC7D;EAEN,MAAM,MAAM,YAAY,KAAK;EAC7B,IAAI,CAAC,KAAK,OAAO,KAAKI,0BAA0B,OAAO,KAAK,YAAY,OAAO;EAE/E,MAAM,WAAW,KAAKH,UAAU,IAAI,GAAG;EACvC,IAAI,UAAU,OAAO;EAErB,MAAM,UAAU,KAAKG,0BAA0B,OAAO,KAAK,YAAY,OAAO,CAAC,CAAC,cAAc;GAE5F,IAAI,KAAKH,UAAU,IAAI,GAAG,MAAM,SAAS,KAAKA,UAAU,OAAO,GAAG;EACpE,CAAC;EACD,KAAKA,UAAU,IAAI,KAAK,OAAO;EAC/B,OAAO;CACT;;CAGA,MAAMG,0BACJ,OACA,KACA,YACA,SACiC;EACjC,MAAM,qBAAqB,KAAK;EAChC,MAAM,iBAAiB,MAAM;EAM7B,IAAI,MAAM,WAAW;GACnB,eAAe,YAAY;IAAE,OAAO;IAAe,SAAS;GAAgC,CAAC;GAC7F,MAAM,aAAa,KAAKC,OAAO;IAC7B,mBAAmB,MAAM;IACzB;IACA,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;IAC3C,GAAI,MAAM,EAAE,IAAI,IAAI,CAAC;IACrB,GAAI,QAAQ,mBAAmB,EAAE,kBAAkB,QAAQ,iBAAiB,IAAI,CAAC;IACjF,GAAI,QAAQ,eAAe,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;GACvE,CAAC;GACD,IAAI;IACF,MAAM,WAAW,0BAA0B,WAAW,MAAM,CAAC;IAC7D,WAAW,yBAAyB,KAAA;IACpC,OAAO;GACT,QAAQ;IACN,MAAM,MAAM,aAAa,IAAI;GAE/B;EACF;EAGA,MAAM,MAAM,KAAK;EACjB,IAAI,MAAM,KAAK,KAAKH,cAAc,KAChC,MAAM,IAAI,mBAAmB,GAAG;EAGlC,eAAe,YAAY;GAAE,OAAO;GAAgB,SAAS;EAA8B,CAAC;EAC5F,MAAM,UAAU,KAAKG,OAAO;GAC1B;GACA,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;GAG3C,GAAI,MAAM,qBAAqB,EAAE,oBAAoB,MAAM,mBAAmB,IAAI,CAAC;GACnF,GAAI,MAAM,EAAE,IAAI,IAAI,CAAC;GACrB,GAAI,QAAQ,mBAAmB,EAAE,kBAAkB,QAAQ,iBAAiB,IAAI,CAAC;GACjF,GAAI,QAAQ,eAAe,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;EACvE,CAAC;EACD,MAAM,WAAW,2BAA2B,QAAQ,MAAM,CAAC;EAC3D,KAAKH,cAAc;EAEnB,IAAI;GACF,MAAM,WAAW,MAAM,2BAA2B,OAAO;GACzD,IAAI,SAAS,WACX,MAAM,MAAM,aAAa,SAAS,SAAS;GAG7C,IAAI,MAAM,sBAAsB,SAAS,2BAA2B,MAAM,oBACxE,QAAQ,yBAAyB,MAAM;GAEzC,OAAO;EACT,SAAS,OAAO;GACd,IAAI,KAAKA,aAAa,GAAG,KAAKA,cAAc;GAC5C,IAAI;IACF,MAAM,QAAQ,OAAO;GACvB,QAAQ,CAER;GACA,MAAM;EACR;CACF;;;;;;;;;CAUA,MAAM,gBAAgB,OAA4B,SAAiD;EACjG,IAAI,SAAS,MACX,IAAI;GACF,MAAM,QAAQ,KAAK;EACrB,QAAQ,CAER;EAEF,IAAI,MAAM,WAAW;GACnB,IAAI,KAAKA,aAAa,GAAG,KAAKA,cAAc;GAC5C,MAAM,MAAM,MAAM;EACpB;CACF;;;;;;;CAQA,MAAM,gBACJ,mBACA,UAAgC,CAAC,GACA;EACjC,MAAM,UAAU,KAAKG,OAAO;GAC1B;GACA,oBAAoB,KAAK;GACzB,GAAI,QAAQ,mBAAmB,EAAE,kBAAkB,QAAQ,iBAAiB,IAAI,CAAC;GACjF,GAAI,QAAQ,eAAe,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;EACvE,CAAC;EACD,MAAM,QAAQ,MAAM;EACpB,OAAO;CACT;AACF"}

package/dist/sandbox/reattach.d.ts

@@ -1,3 +0,0 @@
-import type { SandboxFleet } from './fleet.js';
-export declare function registerSandboxReattach(fleet: SandboxFleet): void;
-//# sourceMappingURL=reattach.d.ts.map

package/dist/sandbox/reattach.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reattach.d.ts","sourceRoot":"","sources":["../../src/sandbox/reattach.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAEjE"}

package/dist/sandbox/reattach.js

@@ -1,16 +0,0 @@
-import { registerSandboxReattach as registerSandboxReattach$1 } from "@mastra/code-sdk/agents/sandbox-reattach";
-//#region src/sandbox/reattach.ts
-/**
-* Wires the core workspace sandbox seam to the factory's sandbox fleet.
-* Core's `getDynamicWorkspace` reattaches project sandboxes through
-* `@mastra/code-sdk/agents/sandbox-reattach`, but only the factory owns the
-* fleet — so `MastraFactory.prepare()` registers the implementation here once
-* the fleet is constructed.
-*/
-function registerSandboxReattach(fleet) {
-	registerSandboxReattach$1((providerSandboxId, options) => fleet.reattachSandbox(providerSandboxId, options));
-}
-//#endregion
-export { registerSandboxReattach };
-
-//# sourceMappingURL=reattach.js.map

package/dist/sandbox/reattach.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reattach.js","names":[],"sources":["../../src/sandbox/reattach.ts"],"sourcesContent":["/**\n * Wires the core workspace sandbox seam to the factory's sandbox fleet.\n * Core's `getDynamicWorkspace` reattaches project sandboxes through\n * `@mastra/code-sdk/agents/sandbox-reattach`, but only the factory owns the\n * fleet — so `MastraFactory.prepare()` registers the implementation here once\n * the fleet is constructed.\n */\nimport { registerSandboxReattach as registerOnCore } from '@mastra/code-sdk/agents/sandbox-reattach';\nimport type { SandboxFleet } from './fleet.js';\n\nexport function registerSandboxReattach(fleet: SandboxFleet): void {\n  registerOnCore((providerSandboxId, options) => fleet.reattachSandbox(providerSandboxId, options));\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,wBAAwB,OAA2B;CACjE,2BAAgB,mBAAmB,YAAY,MAAM,gBAAgB,mBAAmB,OAAO,CAAC;AAClG"}