@mastra/factory 0.0.0 → 0.1.0-alpha.2

package/dist/sandbox/fleet.js

@@ -0,0 +1,259 @@
+// src/sandbox/fleet.ts
+import path from "path";
+function reportProgress(onProgress, event) {
+  if (!onProgress) return;
+  try {
+    onProgress(event);
+  } catch {
+  }
+}
+var SandboxBudgetError = class extends Error {
+  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";
+  }
+  max;
+  code = "sandbox-budget-exceeded";
+};
+function toMaterializationSandbox(sandbox) {
+  if (typeof sandbox.executeCommand !== "function") {
+    throw new Error(
+      `Sandbox provider '${sandbox.provider}' does not implement executeCommand() \u2014 cannot materialize repos.`
+    );
+  }
+  const lifecycle = sandbox;
+  return {
+    id: sandbox.id,
+    start: async () => {
+      await (lifecycle._start ?? sandbox.start)?.call(sandbox);
+    },
+    getInfo: async () => await sandbox.getInfo?.() ?? {},
+    executeCommand: (command, args, options) => sandbox.executeCommand(command, args, options),
+    stop: async () => {
+      await (lifecycle._stop ?? sandbox.stop)?.call(sandbox);
+    }
+  };
+}
+async function readProviderSandboxId(sandbox) {
+  const info = await sandbox.getInfo();
+  const id = info.metadata?.railwaySandboxId ?? info.metadata?.sandboxId;
+  return typeof id === "string" ? id : sandbox.id;
+}
+function sanitizeSegment(segment) {
+  const cleaned = segment.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^\.+/, "");
+  return cleaned || "repo";
+}
+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}`);
+}
+var SandboxFleet = class {
+  #config;
+  #factory;
+  #liveCount = 0;
+  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";
+  }
+  /**
+   * 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 machine = this.#config?.machine;
+    const minutes = 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.
+   */
+  #build(opts) {
+    if (this.#factory) return this.#factory(opts);
+    if (!this.#config) throw new Error("No sandbox configured");
+    const clone = this.#config.machine.clone({
+      ...opts.providerSandboxId ? { id: opts.providerSandboxId, sandboxId: opts.providerSandboxId } : {},
+      ...opts.env ? { env: opts.env } : {},
+      ...opts.workingDirectory ? { workingDirectory: opts.workingDirectory } : {},
+      ...opts.idleTimeoutMinutes !== void 0 ? { idleTimeoutMinutes: opts.idleTimeoutMinutes } : {},
+      ...opts.checkpointName ? { checkpointName: opts.checkpointName } : {}
+    });
+    return toMaterializationSandbox(clone);
+  }
+  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 idleTimeoutMinutes = this.idleMinutes;
+    const checkpointName = store.checkpointName;
+    if (store.sandboxId) {
+      reportProgress(onProgress, { phase: "reattaching", message: "Reconnecting to your sandbox\u2026" });
+      const reattached = this.#build({
+        providerSandboxId: store.sandboxId,
+        idleTimeoutMinutes,
+        ...checkpointName ? { checkpointName } : {},
+        ...env ? { env } : {},
+        ...options.workingDirectory ? { workingDirectory: options.workingDirectory } : {}
+      });
+      try {
+        await reattached.start();
+        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\u2026" });
+    const sandbox = this.#build({
+      idleTimeoutMinutes,
+      ...checkpointName ? { checkpointName } : {},
+      ...env ? { env } : {},
+      ...options.workingDirectory ? { workingDirectory: options.workingDirectory } : {}
+    });
+    await sandbox.start();
+    this.#liveCount += 1;
+    const providerSandboxId = await readProviderSandboxId(sandbox);
+    if (providerSandboxId) {
+      await store.setSandboxId(providerSandboxId);
+    }
+    return sandbox;
+  }
+  /**
+   * 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 } : {}
+    });
+    await sandbox.start();
+    return sandbox;
+  }
+};
+export {
+  SandboxBudgetError,
+  SandboxFleet,
+  reportProgress,
+  resolveContainedLocalWorkdir
+};
+//# sourceMappingURL=fleet.js.map

package/dist/sandbox/fleet.js.map

@@ -0,0 +1 @@
+{"version":3,"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\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  start(): Promise<void>;\n  getInfo(): Promise<{ metadata?: Record<string, unknown> }>;\n  executeCommand(command: string, args?: string[], options?: { timeout?: number }): Promise<SandboxCommandResult>;\n  /** Tear down the underlying VM. Optional: providers without it are no-ops. */\n  stop?(): Promise<void>;\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  /** Environment variables baked into the sandbox. */\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\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}\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  /** 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 * 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(sandbox: WorkspaceSandbox): 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  return {\n    id: sandbox.id,\n    start: async () => {\n      await (lifecycle._start ?? sandbox.start)?.call(sandbox);\n    },\n    getInfo: async () => (await sandbox.getInfo?.()) ?? {},\n    executeCommand: (command, args, options) => sandbox.executeCommand!(command, args, options),\n    stop: async () => {\n      await (lifecycle._stop ?? sandbox.stop)?.call(sandbox);\n    },\n  };\n}\n\n/**\n * The provider's reattach id for a started sandbox. For Railway this is the\n * underlying `railwaySandboxId` in `getInfo().metadata`. Providers without a\n * provider-native id (e.g. local) reattach by construction id, so fall back\n * to the sandbox's own logical id.\n */\nasync function readProviderSandboxId(sandbox: MaterializationSandbox): Promise<string | undefined> {\n  const info = await sandbox.getInfo();\n  const id = info.metadata?.railwaySandboxId ?? info.metadata?.sandboxId;\n  return typeof id === 'string' ? id : sandbox.id;\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\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   * 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  #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.env ? { env: opts.env } : {}),\n      ...(opts.workingDirectory ? { workingDirectory: opts.workingDirectory } : {}),\n      ...(opts.idleTimeoutMinutes !== undefined ? { idleTimeoutMinutes: opts.idleTimeoutMinutes } : {}),\n      ...(opts.checkpointName ? { checkpointName: opts.checkpointName } : {}),\n    });\n    return toMaterializationSandbox(clone);\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  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    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      });\n      try {\n        await reattached.start();\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      ...(env ? { env } : {}),\n      ...(options.workingDirectory ? { workingDirectory: options.workingDirectory } : {}),\n    });\n    await sandbox.start();\n    this.#liveCount += 1;\n\n    const providerSandboxId = await readProviderSandboxId(sandbox);\n    if (providerSandboxId) {\n      await store.setSandboxId(providerSandboxId);\n    }\n\n    return sandbox;\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    });\n    await sandbox.start();\n    return sandbox;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/sandbox/reattach.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,9 @@
+// src/sandbox/reattach.ts
+import { registerSandboxReattach as registerOnCore } from "@mastra/code-sdk/agents/sandbox-reattach";
+function registerSandboxReattach(fleet) {
+  registerOnCore((providerSandboxId) => fleet.reattachSandbox(providerSandboxId));
+}
+export {
+  registerSandboxReattach
+};
+//# sourceMappingURL=reattach.js.map

package/dist/sandbox/reattach.js.map

@@ -0,0 +1 @@
+{"version":3,"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 => fleet.reattachSandbox(providerSandboxId));\n}\n"],"mappings":";AAOA,SAAS,2BAA2B,sBAAsB;AAGnD,SAAS,wBAAwB,OAA2B;AACjE,iBAAe,uBAAqB,MAAM,gBAAgB,iBAAiB,CAAC;AAC9E;","names":[]}

package/dist/server-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Server-wide error handler for the MastraCode web surface.
+ *
+ * Installed as `server.onError`, which the deployer applies to the top-level
+ * Hono app AND the custom-route sub-app (`/web/*`, `/auth/*`) — without it,
+ * unexpected route errors surface as an opaque `Internal Server Error` with no
+ * server-side trace.
+ */
+import type { Context } from 'hono';
+/** Handle a route error: log full detail server-side, return structured JSON. */
+export declare function handleServerError(err: Error, c: Context): Response;
+//# sourceMappingURL=server-error.d.ts.map

package/dist/server-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-error.d.ts","sourceRoot":"","sources":["../src/server-error.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAGpC,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,GAAG,QAAQ,CAiBlE"}

package/dist/server-error.js

@@ -0,0 +1,20 @@
+// src/server-error.ts
+import { HTTPException } from "hono/http-exception";
+function handleServerError(err, c) {
+  if (err instanceof HTTPException) {
+    return c.json({ error: err.message }, err.status);
+  }
+  const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+  console.error(`[MastraCode Web] ${c.req.method} ${c.req.path} failed: ${detail}`);
+  return c.json(
+    {
+      error: "internal_error",
+      message: err instanceof Error ? err.message : String(err)
+    },
+    500
+  );
+}
+export {
+  handleServerError
+};
+//# sourceMappingURL=server-error.js.map

package/dist/server-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server-error.ts"],"sourcesContent":["/**\n * Server-wide error handler for the MastraCode web surface.\n *\n * Installed as `server.onError`, which the deployer applies to the top-level\n * Hono app AND the custom-route sub-app (`/web/*`, `/auth/*`) — without it,\n * unexpected route errors surface as an opaque `Internal Server Error` with no\n * server-side trace.\n */\n\nimport type { Context } from 'hono';\nimport { HTTPException } from 'hono/http-exception';\n\n/** Handle a route error: log full detail server-side, return structured JSON. */\nexport function handleServerError(err: Error, c: Context): Response {\n  // Deliberate HTTP errors (auth middleware, body limits, handlers) keep their\n  // status + message; they are expected flows, not server faults.\n  if (err instanceof HTTPException) {\n    return c.json({ error: err.message }, err.status);\n  }\n\n  const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);\n  console.error(`[MastraCode Web] ${c.req.method} ${c.req.path} failed: ${detail}`);\n\n  return c.json(\n    {\n      error: 'internal_error',\n      message: err instanceof Error ? err.message : String(err),\n    },\n    500,\n  );\n}\n"],"mappings":";AAUA,SAAS,qBAAqB;AAGvB,SAAS,kBAAkB,KAAY,GAAsB;AAGlE,MAAI,eAAe,eAAe;AAChC,WAAO,EAAE,KAAK,EAAE,OAAO,IAAI,QAAQ,GAAG,IAAI,MAAM;AAAA,EAClD;AAEA,QAAM,SAAS,eAAe,QAAS,IAAI,SAAS,IAAI,UAAW,OAAO,GAAG;AAC7E,UAAQ,MAAM,oBAAoB,EAAE,IAAI,MAAM,IAAI,EAAE,IAAI,IAAI,YAAY,MAAM,EAAE;AAEhF,SAAO,EAAE;AAAA,IACP;AAAA,MACE,OAAO;AAAA,MACP,SAAS,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAAA,IAC1D;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/skills/service.d.ts

@@ -0,0 +1,48 @@
+import type { MastraCodeState } from '@mastra/code-sdk/schema';
+import type { SendAgentSignalResult } from '@mastra/core/agent';
+import type { AgentController } from '@mastra/core/agent-controller';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { Workspace } from '@mastra/core/workspace';
+export interface SkillInvocationInput {
+    resourceId: string;
+    scope?: string;
+    name: string;
+    arguments?: string;
+}
+export interface SkillSession {
+    getWorkspace(): Workspace;
+    sendMessage(input: {
+        content: string;
+    }): Promise<unknown>;
+    sendNotificationSignal(input: {
+        source: string;
+        kind: string;
+        summary: string;
+        priority?: 'low' | 'medium' | 'high' | 'urgent';
+        payload?: unknown;
+        dedupeKey?: string;
+        sourceId?: string;
+    }, options?: {
+        ifActive?: {
+            behavior?: 'deliver' | 'persist';
+        };
+        ifIdle?: {
+            behavior?: 'persist' | 'wake';
+        };
+        requestContext?: RequestContext;
+    }): Promise<Pick<SendAgentSignalResult, 'persisted' | 'accepted'>>;
+}
+export declare class SkillInvocationError extends Error {
+    readonly code: 'session_not_found' | 'skill_not_found';
+    constructor(code: SkillInvocationError['code'], message: string);
+}
+export declare function resolveSkillInvocation(controller: Pick<AgentController<MastraCodeState>, 'getSessionByResource'>, input: SkillInvocationInput): Promise<{
+    session: SkillSession;
+    skillName: string;
+    message: string;
+}>;
+export declare function dispatchSkillInvocation(controller: Pick<AgentController<MastraCodeState>, 'getSessionByResource'>, input: SkillInvocationInput): Promise<{
+    skillName: string;
+    message: string;
+}>;
+//# sourceMappingURL=service.d.ts.map

package/dist/skills/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/skills/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,IAAI,SAAS,CAAC;IAC1B,WAAW,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,sBAAsB,CACpB,KAAK,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;QAChD,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,EACD,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,EAAE;YAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;SAAE,CAAC;QAChD,MAAM,CAAC,EAAE;YAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,MAAM,CAAA;SAAE,CAAC;QAC3C,cAAc,CAAC,EAAE,cAAc,CAAC;KACjC,GACA,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC;CACnE;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,mBAAmB,GAAG,iBAAiB,CAAC;gBAE3C,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM;CAKhE;AAMD,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,sBAAsB,CAAC,EAC1E,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAkBxE;AAED,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,sBAAsB,CAAC,EAC1E,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAIjD"}

package/dist/skills/service.js

@@ -0,0 +1,45 @@
+// src/skills/service.ts
+import { formatSkillActivation } from "@mastra/core/workspace";
+var SkillInvocationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SkillInvocationError";
+    this.code = code;
+  }
+};
+function escapeSkillBoundary(value) {
+  return value.replaceAll("</skill>", "&lt;/skill&gt;");
+}
+async function resolveSkillInvocation(controller, input) {
+  const session = await controller.getSessionByResource(input.resourceId, input.scope);
+  if (!session) throw new SkillInvocationError("session_not_found", "Agent controller session not found.");
+  const skills = session.getWorkspace().skills;
+  await skills?.maybeRefresh();
+  const skill = await skills?.get(input.name);
+  if (!skill || skill["user-invocable"] === false) {
+    throw new SkillInvocationError("skill_not_found", `Skill not found: ${input.name}.`);
+  }
+  const args = input.arguments?.trim();
+  const content = `${formatSkillActivation(skill)}${args ? `
+
+ARGUMENTS: ${args}` : ""}`.trim();
+  return {
+    session,
+    skillName: skill.name,
+    message: `<skill name="${skill.name}">
+${escapeSkillBoundary(content)}
+</skill>`
+  };
+}
+async function dispatchSkillInvocation(controller, input) {
+  const resolved = await resolveSkillInvocation(controller, input);
+  await resolved.session.sendMessage({ content: resolved.message });
+  return { skillName: resolved.skillName, message: resolved.message };
+}
+export {
+  SkillInvocationError,
+  dispatchSkillInvocation,
+  resolveSkillInvocation
+};
+//# sourceMappingURL=service.js.map

package/dist/skills/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/skills/service.ts"],"sourcesContent":["import type { MastraCodeState } from '@mastra/code-sdk/schema';\nimport type { SendAgentSignalResult } from '@mastra/core/agent';\nimport type { AgentController } from '@mastra/core/agent-controller';\nimport type { RequestContext } from '@mastra/core/request-context';\nimport { formatSkillActivation } from '@mastra/core/workspace';\nimport type { Workspace } from '@mastra/core/workspace';\n\nexport interface SkillInvocationInput {\n  resourceId: string;\n  scope?: string;\n  name: string;\n  arguments?: string;\n}\n\nexport interface SkillSession {\n  getWorkspace(): Workspace;\n  sendMessage(input: { content: string }): Promise<unknown>;\n  sendNotificationSignal(\n    input: {\n      source: string;\n      kind: string;\n      summary: string;\n      priority?: 'low' | 'medium' | 'high' | 'urgent';\n      payload?: unknown;\n      dedupeKey?: string;\n      sourceId?: string;\n    },\n    options?: {\n      ifActive?: { behavior?: 'deliver' | 'persist' };\n      ifIdle?: { behavior?: 'persist' | 'wake' };\n      requestContext?: RequestContext;\n    },\n  ): Promise<Pick<SendAgentSignalResult, 'persisted' | 'accepted'>>;\n}\n\nexport class SkillInvocationError extends Error {\n  readonly code: 'session_not_found' | 'skill_not_found';\n\n  constructor(code: SkillInvocationError['code'], message: string) {\n    super(message);\n    this.name = 'SkillInvocationError';\n    this.code = code;\n  }\n}\n\nfunction escapeSkillBoundary(value: string): string {\n  return value.replaceAll('</skill>', '&lt;/skill&gt;');\n}\n\nexport async function resolveSkillInvocation(\n  controller: Pick<AgentController<MastraCodeState>, 'getSessionByResource'>,\n  input: SkillInvocationInput,\n): Promise<{ session: SkillSession; skillName: string; message: string }> {\n  const session = (await controller.getSessionByResource(input.resourceId, input.scope)) as SkillSession | undefined;\n  if (!session) throw new SkillInvocationError('session_not_found', 'Agent controller session not found.');\n\n  const skills = session.getWorkspace().skills;\n  await skills?.maybeRefresh();\n  const skill = await skills?.get(input.name);\n  if (!skill || skill['user-invocable'] === false) {\n    throw new SkillInvocationError('skill_not_found', `Skill not found: ${input.name}.`);\n  }\n\n  const args = input.arguments?.trim();\n  const content = `${formatSkillActivation(skill)}${args ? `\\n\\nARGUMENTS: ${args}` : ''}`.trim();\n  return {\n    session,\n    skillName: skill.name,\n    message: `<skill name=\"${skill.name}\">\\n${escapeSkillBoundary(content)}\\n</skill>`,\n  };\n}\n\nexport async function dispatchSkillInvocation(\n  controller: Pick<AgentController<MastraCodeState>, 'getSessionByResource'>,\n  input: SkillInvocationInput,\n): Promise<{ skillName: string; message: string }> {\n  const resolved = await resolveSkillInvocation(controller, input);\n  await resolved.session.sendMessage({ content: resolved.message });\n  return { skillName: resolved.skillName, message: resolved.message };\n}\n"],"mappings":";AAIA,SAAS,6BAA6B;AA+B/B,IAAM,uBAAN,cAAmC,MAAM;AAAA,EACrC;AAAA,EAET,YAAY,MAAoC,SAAiB;AAC/D,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,OAAO;AAAA,EACd;AACF;AAEA,SAAS,oBAAoB,OAAuB;AAClD,SAAO,MAAM,WAAW,YAAY,gBAAgB;AACtD;AAEA,eAAsB,uBACpB,YACA,OACwE;AACxE,QAAM,UAAW,MAAM,WAAW,qBAAqB,MAAM,YAAY,MAAM,KAAK;AACpF,MAAI,CAAC,QAAS,OAAM,IAAI,qBAAqB,qBAAqB,qCAAqC;AAEvG,QAAM,SAAS,QAAQ,aAAa,EAAE;AACtC,QAAM,QAAQ,aAAa;AAC3B,QAAM,QAAQ,MAAM,QAAQ,IAAI,MAAM,IAAI;AAC1C,MAAI,CAAC,SAAS,MAAM,gBAAgB,MAAM,OAAO;AAC/C,UAAM,IAAI,qBAAqB,mBAAmB,oBAAoB,MAAM,IAAI,GAAG;AAAA,EACrF;AAEA,QAAM,OAAO,MAAM,WAAW,KAAK;AACnC,QAAM,UAAU,GAAG,sBAAsB,KAAK,CAAC,GAAG,OAAO;AAAA;AAAA,aAAkB,IAAI,KAAK,EAAE,GAAG,KAAK;AAC9F,SAAO;AAAA,IACL;AAAA,IACA,WAAW,MAAM;AAAA,IACjB,SAAS,gBAAgB,MAAM,IAAI;AAAA,EAAO,oBAAoB,OAAO,CAAC;AAAA;AAAA,EACxE;AACF;AAEA,eAAsB,wBACpB,YACA,OACiD;AACjD,QAAM,WAAW,MAAM,uBAAuB,YAAY,KAAK;AAC/D,QAAM,SAAS,QAAQ,YAAY,EAAE,SAAS,SAAS,QAAQ,CAAC;AAChE,SAAO,EAAE,WAAW,SAAS,WAAW,SAAS,SAAS,QAAQ;AACpE;","names":[]}

package/dist/spa-static.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Same-origin SPA serving for production.
+ *
+ * In dev the SPA is served by Vite (:5173) which proxies API paths to the
+ * server (:4111) — this module is effectively idle there. In production the
+ * built SPA (vite output) is served by the API server itself at `/`, so the
+ * app is a single origin and no CORS / separate static host is required.
+ *
+ * The middleware is mounted via the Mastra entry's `server.middleware`, which
+ * the deployer applies before routes: real file hits and SPA navigations are
+ * answered here, everything else falls through to the API routes.
+ */
+import type { Context } from 'hono';
+/**
+ * Locate the built SPA (a dir containing `index.html`). Checked in order:
+ *   1. `MASTRACODE_UI_DIST` — explicit override for custom layouts.
+ *   2. `ui/` next to the bundled server module — vite builds into
+ *      `src/mastra/public/ui` and `mastra build` copies `public/` into
+ *      `.mastra/output/`, so the build output is self-contained.
+ *   3. `src/mastra/public/ui` under cwd — the vite outDir when running from
+ *      the package root before `mastra build`.
+ * Returns `undefined` when no build is found (e.g. plain `mastra dev` without
+ * a prior vite build), in which case the middleware is simply not mounted.
+ */
+export declare function resolveUiDistDir(): string | undefined;
+/**
+ * Hono middleware serving the built SPA from `uiDist`:
+ *   - exact file hits (js/css/assets) are served directly,
+ *   - GET navigations to non-server paths fall back to `index.html` (SPA
+ *     client-side routing),
+ *   - `/api`, `/web`, `/auth` and non-GET requests always pass through.
+ */
+export declare function createSpaStaticMiddleware(uiDist: string): (c: Context, next: () => Promise<void>) => Promise<Response | void>;
+//# sourceMappingURL=spa-static.d.ts.map

package/dist/spa-static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spa-static.d.ts","sourceRoot":"","sources":["../src/spa-static.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AA0BpC;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAUrD;AAmBD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,IACxC,GAAG,OAAO,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAuB/E"}

package/dist/spa-static.js

@@ -0,0 +1,73 @@
+// src/spa-static.ts
+import { existsSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { dirname, extname, join, normalize, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".txt": "text/plain; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm"
+};
+var SERVER_PREFIXES = ["/api", "/web", "/auth"];
+function resolveUiDistDir() {
+  const candidates = [
+    process.env.MASTRACODE_UI_DIST,
+    join(dirname(fileURLToPath(import.meta.url)), "ui"),
+    resolve(process.cwd(), "src/mastra/public/ui")
+  ];
+  for (const candidate of candidates) {
+    if (candidate && existsSync(join(candidate, "index.html"))) return resolve(candidate);
+  }
+  return void 0;
+}
+async function isFile(path) {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function serveFile(c, filePath, immutable) {
+  const data = await readFile(filePath);
+  c.header("Content-Type", MIME[extname(filePath).toLowerCase()] ?? "application/octet-stream");
+  c.header("Cache-Control", immutable ? "public, max-age=31536000, immutable" : "no-cache");
+  return c.body(new Uint8Array(data));
+}
+function createSpaStaticMiddleware(uiDist) {
+  return async (c, next) => {
+    if (c.req.method !== "GET" && c.req.method !== "HEAD") return next();
+    const path = c.req.path;
+    if (SERVER_PREFIXES.some((prefix) => path === prefix || path.startsWith(`${prefix}/`))) return next();
+    const relative = normalize(decodeURIComponent(path)).replace(/^[/\\]+/, "");
+    const filePath = resolve(uiDist, relative);
+    const uiDistPrefix = uiDist.endsWith(sep) ? uiDist : uiDist + sep;
+    if (filePath.startsWith(uiDistPrefix) && relative !== "" && await isFile(filePath)) {
+      return serveFile(c, filePath, relative.startsWith("assets/"));
+    }
+    const accept = c.req.header("Accept") ?? "";
+    if (path === "/" || accept.includes("text/html")) {
+      return serveFile(c, join(uiDist, "index.html"), false);
+    }
+    return next();
+  };
+}
+export {
+  createSpaStaticMiddleware,
+  resolveUiDistDir
+};
+//# sourceMappingURL=spa-static.js.map

package/dist/spa-static.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/spa-static.ts"],"sourcesContent":["/**\n * Same-origin SPA serving for production.\n *\n * In dev the SPA is served by Vite (:5173) which proxies API paths to the\n * server (:4111) — this module is effectively idle there. In production the\n * built SPA (vite output) is served by the API server itself at `/`, so the\n * app is a single origin and no CORS / separate static host is required.\n *\n * The middleware is mounted via the Mastra entry's `server.middleware`, which\n * the deployer applies before routes: real file hits and SPA navigations are\n * answered here, everything else falls through to the API routes.\n */\n\nimport { existsSync } from 'node:fs';\nimport { readFile, stat } from 'node:fs/promises';\nimport { dirname, extname, join, normalize, resolve, sep } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport type { Context } from 'hono';\n\nconst MIME: Record<string, string> = {\n  '.html': 'text/html; charset=utf-8',\n  '.js': 'text/javascript; charset=utf-8',\n  '.mjs': 'text/javascript; charset=utf-8',\n  '.css': 'text/css; charset=utf-8',\n  '.json': 'application/json',\n  '.map': 'application/json',\n  '.svg': 'image/svg+xml',\n  '.png': 'image/png',\n  '.jpg': 'image/jpeg',\n  '.jpeg': 'image/jpeg',\n  '.gif': 'image/gif',\n  '.webp': 'image/webp',\n  '.ico': 'image/x-icon',\n  '.txt': 'text/plain; charset=utf-8',\n  '.woff': 'font/woff',\n  '.woff2': 'font/woff2',\n  '.ttf': 'font/ttf',\n  '.wasm': 'application/wasm',\n};\n\n/** Server-owned path prefixes the SPA middleware must never answer for. */\nconst SERVER_PREFIXES = ['/api', '/web', '/auth'];\n\n/**\n * Locate the built SPA (a dir containing `index.html`). Checked in order:\n *   1. `MASTRACODE_UI_DIST` — explicit override for custom layouts.\n *   2. `ui/` next to the bundled server module — vite builds into\n *      `src/mastra/public/ui` and `mastra build` copies `public/` into\n *      `.mastra/output/`, so the build output is self-contained.\n *   3. `src/mastra/public/ui` under cwd — the vite outDir when running from\n *      the package root before `mastra build`.\n * Returns `undefined` when no build is found (e.g. plain `mastra dev` without\n * a prior vite build), in which case the middleware is simply not mounted.\n */\nexport function resolveUiDistDir(): string | undefined {\n  const candidates = [\n    process.env.MASTRACODE_UI_DIST,\n    join(dirname(fileURLToPath(import.meta.url)), 'ui'),\n    resolve(process.cwd(), 'src/mastra/public/ui'),\n  ];\n  for (const candidate of candidates) {\n    if (candidate && existsSync(join(candidate, 'index.html'))) return resolve(candidate);\n  }\n  return undefined;\n}\n\nasync function isFile(path: string): Promise<boolean> {\n  try {\n    return (await stat(path)).isFile();\n  } catch {\n    return false;\n  }\n}\n\nasync function serveFile(c: Context, filePath: string, immutable: boolean): Promise<Response> {\n  const data = await readFile(filePath);\n  c.header('Content-Type', MIME[extname(filePath).toLowerCase()] ?? 'application/octet-stream');\n  // Vite emits content-hashed filenames under assets/ — cache those forever;\n  // index.html (and anything unhashed) must revalidate so deploys roll out.\n  c.header('Cache-Control', immutable ? 'public, max-age=31536000, immutable' : 'no-cache');\n  return c.body(new Uint8Array(data));\n}\n\n/**\n * Hono middleware serving the built SPA from `uiDist`:\n *   - exact file hits (js/css/assets) are served directly,\n *   - GET navigations to non-server paths fall back to `index.html` (SPA\n *     client-side routing),\n *   - `/api`, `/web`, `/auth` and non-GET requests always pass through.\n */\nexport function createSpaStaticMiddleware(uiDist: string) {\n  return async (c: Context, next: () => Promise<void>): Promise<Response | void> => {\n    if (c.req.method !== 'GET' && c.req.method !== 'HEAD') return next();\n    const path = c.req.path;\n    if (SERVER_PREFIXES.some(prefix => path === prefix || path.startsWith(`${prefix}/`))) return next();\n\n    // Resolve the request path inside uiDist, rejecting traversal escapes.\n    const relative = normalize(decodeURIComponent(path)).replace(/^[/\\\\]+/, '');\n    const filePath = resolve(uiDist, relative);\n    // Use a trailing separator so a sibling like \"ui.key\" can't slip past the\n    // prefix check (same pattern as fs-routes.ts isWithinRoot).\n    const uiDistPrefix = uiDist.endsWith(sep) ? uiDist : uiDist + sep;\n    if (filePath.startsWith(uiDistPrefix) && relative !== '' && (await isFile(filePath))) {\n      return serveFile(c, filePath, relative.startsWith('assets/'));\n    }\n\n    // SPA fallback: serve index.html for root and html navigations.\n    const accept = c.req.header('Accept') ?? '';\n    if (path === '/' || accept.includes('text/html')) {\n      return serveFile(c, join(uiDist, 'index.html'), false);\n    }\n\n    return next();\n  };\n}\n"],"mappings":";AAaA,SAAS,kBAAkB;AAC3B,SAAS,UAAU,YAAY;AAC/B,SAAS,SAAS,SAAS,MAAM,WAAW,SAAS,WAAW;AAChE,SAAS,qBAAqB;AAI9B,IAAM,OAA+B;AAAA,EACnC,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,SAAS;AACX;AAGA,IAAM,kBAAkB,CAAC,QAAQ,QAAQ,OAAO;AAazC,SAAS,mBAAuC;AACrD,QAAM,aAAa;AAAA,IACjB,QAAQ,IAAI;AAAA,IACZ,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC,GAAG,IAAI;AAAA,IAClD,QAAQ,QAAQ,IAAI,GAAG,sBAAsB;AAAA,EAC/C;AACA,aAAW,aAAa,YAAY;AAClC,QAAI,aAAa,WAAW,KAAK,WAAW,YAAY,CAAC,EAAG,QAAO,QAAQ,SAAS;AAAA,EACtF;AACA,SAAO;AACT;AAEA,eAAe,OAAO,MAAgC;AACpD,MAAI;AACF,YAAQ,MAAM,KAAK,IAAI,GAAG,OAAO;AAAA,EACnC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,eAAe,UAAU,GAAY,UAAkB,WAAuC;AAC5F,QAAM,OAAO,MAAM,SAAS,QAAQ;AACpC,IAAE,OAAO,gBAAgB,KAAK,QAAQ,QAAQ,EAAE,YAAY,CAAC,KAAK,0BAA0B;AAG5F,IAAE,OAAO,iBAAiB,YAAY,wCAAwC,UAAU;AACxF,SAAO,EAAE,KAAK,IAAI,WAAW,IAAI,CAAC;AACpC;AASO,SAAS,0BAA0B,QAAgB;AACxD,SAAO,OAAO,GAAY,SAAwD;AAChF,QAAI,EAAE,IAAI,WAAW,SAAS,EAAE,IAAI,WAAW,OAAQ,QAAO,KAAK;AACnE,UAAM,OAAO,EAAE,IAAI;AACnB,QAAI,gBAAgB,KAAK,YAAU,SAAS,UAAU,KAAK,WAAW,GAAG,MAAM,GAAG,CAAC,EAAG,QAAO,KAAK;AAGlG,UAAM,WAAW,UAAU,mBAAmB,IAAI,CAAC,EAAE,QAAQ,WAAW,EAAE;AAC1E,UAAM,WAAW,QAAQ,QAAQ,QAAQ;AAGzC,UAAM,eAAe,OAAO,SAAS,GAAG,IAAI,SAAS,SAAS;AAC9D,QAAI,SAAS,WAAW,YAAY,KAAK,aAAa,MAAO,MAAM,OAAO,QAAQ,GAAI;AACpF,aAAO,UAAU,GAAG,UAAU,SAAS,WAAW,SAAS,CAAC;AAAA,IAC9D;AAGA,UAAM,SAAS,EAAE,IAAI,OAAO,QAAQ,KAAK;AACzC,QAAI,SAAS,OAAO,OAAO,SAAS,WAAW,GAAG;AAChD,aAAO,UAAU,GAAG,KAAK,QAAQ,YAAY,GAAG,KAAK;AAAA,IACvD;AAEA,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}