@mastra/platform-workspace 0.0.0-esbuild-bundle-worker-20260807173433

package/dist/sandbox.d.ts

@@ -0,0 +1,393 @@
+import type { RequestContext } from '@mastra/core/di';
+import type { CommandResult, ExecuteCommandOptions, InstructionsOption, MastraSandboxOptions, ProcessInfo, ProviderStatus, SandboxCloneOptions, SandboxInfo, SpawnProcessOptions } from '@mastra/core/workspace';
+import { MastraSandbox, ProcessHandle, SandboxProcessManager } from '@mastra/core/workspace';
+import type { PlatformClientOptions } from './client.js';
+import type { DirectExecWebSocketFactory } from './direct-exec.js';
+import type { PrivateNetFetch } from './private-net-exec.js';
+export type PlatformSandboxNetworkIsolation = 'ISOLATED' | 'PRIVATE';
+/**
+ * In-process `sandboxId → instanceUrl` map that lets
+ * {@link PlatformSandbox.executeCommand} dial the in-sandbox sidecar over
+ * Railway's private network instead of paying for a lease + WebSocket
+ * round-trip through Railway's public control plane.
+ *
+ * The workspace proxy discovers each sandbox's IPv6 during
+ * `POST /v1/projects/:pid/sandbox` and returns it as `instanceUrl` on the
+ * create + get responses (see the platform inline-discovery issue). The
+ * `PlatformSandbox` client copies that field into this registry from both
+ * {@link PlatformSandbox.start} branches (fresh provision + reattach), evicts
+ * on {@link PlatformSandbox.destroy}, and evicts again on any observed
+ * transport failure so the next exec falls back to the lease path cleanly.
+ *
+ * See:
+ *   - `.scratch/factory-deploy/issue-runtime-sandbox-address-discovery.md`
+ *   - `.scratch/factory-deploy/issue-platform-sandbox-exec-via-private-network.md`
+ */
+export interface SandboxAddressRegistry {
+    set(sandboxId: string, instanceUrl: string): void;
+    get(sandboxId: string): string | undefined;
+    delete(sandboxId: string): void;
+}
+export interface PlatformSandboxOptions extends Omit<MastraSandboxOptions, 'processes'>, PlatformClientOptions {
+    id?: string;
+    environmentId?: string;
+    sandboxId?: string;
+    idleTimeoutMinutes?: number;
+    networkIsolation?: PlatformSandboxNetworkIsolation;
+    env?: Record<string, string>;
+    timeout?: number;
+    instructions?: InstructionsOption;
+    /**
+     * Injected WebSocket factory used by the direct-exec code path. Defaults to
+     * the global `WebSocket` (available on Node 22+, this package's minimum) and
+     * only exists so tests can drive the exec state machine deterministically
+     * without a real network socket.
+     */
+    webSocketFactory?: DirectExecWebSocketFactory;
+    /**
+     * Injected fetch implementation used by the private-network exec code path
+     * to dial the in-sandbox sidecar. Defaults to `globalThis.fetch` and only
+     * exists so tests can drive that transport without a real HTTP server.
+     * Note: this is separate from the `fetch` on {@link PlatformClientOptions},
+     * which is used for calls to the workspace proxy.
+     */
+    privateNetFetch?: PrivateNetFetch;
+    /**
+     * Registry that maps `sandboxId → instanceUrl` for the private-network
+     * exec path. When set, {@link PlatformSandbox.start} populates it from the
+     * `instanceUrl` field workspace-proxy returns on create + get responses,
+     * and {@link PlatformSandbox.executeCommand} looks it up before every exec
+     * and tries the private-network transport first, falling back to the lease
+     * path on any transport failure (and invalidating the registry entry so
+     * the next call goes to the lease path cleanly). When absent, all execs
+     * go straight to the lease path — this is the pre-existing behavior and
+     * the expected mode outside the shipyard runtime. See
+     * {@link SandboxAddressRegistry}.
+     */
+    addressRegistry?: SandboxAddressRegistry;
+}
+/**
+ * Diagnostic error thrown when the direct-exec WebSocket transport fails
+ * twice in a row (opening handshake refused or socket closed mid-stream
+ * without an `exit` frame). Distinguishes "the sandbox transport is broken"
+ * from "your command failed" so callers can decide whether to retry at a
+ * higher level (e.g. reprovision the sandbox) or surface the error.
+ *
+ * `opened` is `true` when the WebSocket completed its handshake at least
+ * once before closing; `false` when Railway refused the upgrade outright.
+ */
+export declare class SandboxExecTransportError extends Error {
+    readonly sandboxId: string | undefined;
+    readonly command: string;
+    readonly attempts: number;
+    readonly opened: boolean;
+    readonly closeCode: number | undefined;
+    readonly closeReason: string | undefined;
+    readonly wsEndpoint: string;
+    constructor(message: string, diagnostics: {
+        sandboxId?: string;
+        command: string;
+        attempts: number;
+        opened: boolean;
+        closeCode?: number;
+        closeReason?: string;
+        wsEndpoint: string;
+    });
+}
+/**
+ * Outcome of {@link PlatformSandbox.captureCheckpoint}. Mirrors the shape of
+ * the OSS `@mastra/railway` `RailwaySandbox.captureCheckpoint()` return so a
+ * caller (e.g. the factory fleet) can branch on `status`/`reason` uniformly
+ * across providers without knowing which one is underneath.
+ *
+ * `captured` and `coalesced` both represent a successful capture the caller
+ * can persist against — they carry the checkpoint name inline so callers
+ * don't have to reach back into the sandbox instance to learn what was
+ * written. `skipped` carries a machine-readable `reason` so the discriminant
+ * set stays extensible.
+ *
+ * Note: the platform proxy's own `skipped` (returned when the upstream
+ * sandbox is already destroyed) is mapped to `sandbox-not-running` here to
+ * keep the discriminant identical to the OSS provider. The diagnostic
+ * distinction (pre-flight vs post-hoc discovery) is preserved in log lines,
+ * not the return type — see {@link PlatformSandbox.captureCheckpoint}.
+ */
+export type CaptureCheckpointResult = {
+    status: 'captured';
+    checkpointName: string;
+} | {
+    status: 'coalesced';
+    checkpointName: string;
+} | {
+    status: 'skipped';
+    reason: 'no-checkpoint-name-configured' | 'sandbox-not-running';
+};
+/**
+ * Thrown when `/exec-lease` returns 410 Gone — the sandbox has been destroyed
+ * (Railway destroy, quota reclamation, etc.). The client cannot recover from
+ * this on its own because it does not own the binding store; only the fleet
+ * layer can clear the stale sandbox id and provision a fresh one. Callers
+ * (typically `SandboxFleet`) must catch this and reprovision-and-replay.
+ *
+ * When this is thrown the cached `_lease` and `_sandboxId` on the sandbox
+ * instance are cleared, so the next `ensureRunning()` on a reused instance
+ * will re-provision cleanly.
+ */
+export declare class SandboxDestroyedError extends Error {
+    readonly sandboxId: string | undefined;
+    readonly command: string;
+    readonly attempts: number;
+    constructor(message: string, diagnostics: {
+        sandboxId?: string;
+        command: string;
+        attempts: number;
+    });
+}
+declare class PlatformProcessManager extends SandboxProcessManager<PlatformSandbox> {
+    private spawnCounter;
+    /**
+     * Spawn a process on the remote sandbox.
+     *
+     * `command` is interpreted as a shell string by the remote shell, matching
+     * the {@link MastraSandbox} contract. See {@link PlatformSandbox.executeCommand}
+     * for the untrusted-input caveat: never pass untrusted values as `command`.
+     */
+    spawn(command: string, options?: SpawnProcessOptions): Promise<ProcessHandle>;
+    list(): Promise<ProcessInfo[]>;
+}
+export declare class PlatformSandbox extends MastraSandbox {
+    readonly id: string;
+    readonly name = "PlatformSandbox";
+    readonly provider = "platform";
+    status: ProviderStatus;
+    readonly processes: PlatformProcessManager;
+    private readonly _client;
+    private readonly _environmentId;
+    private _sandboxId?;
+    private readonly _idleTimeoutMinutes?;
+    private readonly _networkIsolation?;
+    private readonly _env;
+    private readonly _timeout?;
+    private readonly _instructionsOverride?;
+    private _createdAt;
+    private readonly _webSocketFactory?;
+    private readonly _privateNetFetch?;
+    /**
+     * Registry that maps `sandboxId → instanceUrl` for the private-network
+     * exec path. Injected by the composition site via
+     * {@link PlatformSandboxOptions.addressRegistry} and populated by this
+     * class itself in `start()` when the workspace-proxy's create/reattach
+     * response includes an `instanceUrl` field. The registry IS the cache —
+     * there is no per-instance mirror on `PlatformSandbox`, so every exec is
+     * a `Map.get()` (in the default in-process impl) against the live view.
+     * When absent, executes go straight to the lease path with no extra
+     * round-trip.
+     */
+    private readonly _addressRegistry?;
+    /**
+     * Cached exec lease for this sandbox. `null` before the first exec and
+     * after {@link destroy}. Refreshed when `expiresAt - LEASE_REFRESH_MARGIN_MS < now`
+     * (see {@link _ensureLease}); a lease without a disclosed `expiresAt`
+     * is refreshed on every call.
+     */
+    private _lease;
+    /**
+     * In-flight mint request; concurrent `_ensureLease` callers on a cold or
+     * near-expiry cache all await this single promise so we don't burn N
+     * `POST /exec-lease` round-trips when the sandbox is doing N parallel execs.
+     * Cleared (regardless of success or failure) when the request settles.
+     */
+    private _leaseInFlight;
+    /**
+     * True when this sandbox was constructed with a caller-supplied `id` (the
+     * recovery key the proxy hashes into an on-provider checkpoint name).
+     * `captureCheckpoint()` needs this to distinguish "no checkpoint intent"
+     * (auto-generated random id — capture would land under a name no future
+     * boot would look for) from "capture on demand". Cloned sandboxes route
+     * `checkpointName` through `id`, so both entry points set this the same
+     * way.
+     */
+    private readonly _hasRecoveryKey;
+    /**
+     * In-flight `captureCheckpoint()` request. Concurrent callers on the same
+     * instance coalesce onto this single promise so we don't burn N `POST
+     * /checkpoint` round-trips when the fleet fires several turn-end captures
+     * before the first one resolves. Cleared when the request settles.
+     */
+    private _captureInFlight;
+    constructor(options?: PlatformSandboxOptions);
+    private generateId;
+    /**
+     * Construct a sibling {@link PlatformSandbox} that inherits this sandbox's
+     * credentials and defaults (access token, project, environment, network
+     * isolation, timeout, instructions, env, idle timeout) with per-instance
+     * overrides from `options`.
+     *
+     * Performs no I/O and does not require this sandbox to be started — the
+     * returned sandbox is not started and provisions (or reattaches, when
+     * `sandboxId` is set) on its own `start()`. Use it when one configured
+     * sandbox acts as the template for a fleet of independent sandboxes
+     * (e.g. one per project).
+     */
+    clone(options?: SandboxCloneOptions): PlatformSandbox;
+    start(): Promise<void>;
+    /**
+     * Copy `response.instanceUrl` into the injected {@link SandboxAddressRegistry}
+     * when both are present. Called from both {@link start} branches (fresh
+     * provision + reattach) with the workspace-proxy response for this sandbox.
+     *
+     * The proxy discovers the IPv6 during `Sandbox.create()` and stores it in
+     * `environment_sandboxes.instance_url`; both the create response and
+     * `GET /sandbox/:id` echo the same field. The runtime does not do any
+     * discovery of its own — it only mirrors the field into an in-process map
+     * so {@link executeCommand} can `Map.get()` before every exec without an
+     * HTTP round-trip.
+     *
+     * `null`/absent `instanceUrl` (proxy discovery failed, or an older proxy
+     * that predates the field) leaves the registry untouched — executes fall
+     * through to the lease path with no branch here.
+     */
+    private _populateAddressFromResponse;
+    stop(): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * Capture the sandbox's checkpoint on demand, outside any refresh timer the
+     * workspace-proxy owns internally.
+     *
+     * Intended for callers (e.g. a factory-side scheduler) that want to refresh
+     * the recovery checkpoint at semantic moments — turn end, session-idle,
+     * pre-teardown — rather than only just before the upstream's idle destroy.
+     *
+     * Mirrors the OSS `@mastra/railway` `RailwaySandbox.captureCheckpoint()`
+     * shape so factory can call `sandbox.captureCheckpoint()` uniformly and
+     * branch on `status`/`reason` without knowing which provider is underneath.
+     * Both `captured` and `coalesced` carry the checkpoint name inline so the
+     * caller can persist a session→checkpoint binding atomically with the
+     * awaited capture.
+     *
+     * Skip semantics:
+     *  - No caller-supplied `id`: returns `{ status: 'skipped', reason:
+     *    'no-checkpoint-name-configured' }`. An auto-generated random id is
+     *    never a meaningful recovery key (no future boot would look for a
+     *    checkpoint under it), so capturing would silently produce dead data.
+     *  - Not started (no `_sandboxId`): returns `{ status: 'skipped', reason:
+     *    'sandbox-not-running' }` without a round-trip.
+     *  - Upstream 410 (workspace-proxy or Railway reports the sandbox is
+     *    already destroyed): returns the same `sandbox-not-running` skip so
+     *    the discriminant matches the pre-flight case. Local state
+     *    (`_sandboxId`, `_lease`, sidecar address) is cleared as a side
+     *    effect so the next `start()` provisions fresh instead of reattaching
+     *    to a dead id. The diagnostic distinction (pre-flight vs post-hoc)
+     *    is preserved in log level: debug for the expected pre-flight skip,
+     *    warn for the surprise upstream destroy.
+     *
+     * Concurrent callers on the same instance coalesce onto a single in-flight
+     * `POST /checkpoint` so N simultaneous turn-end fires (e.g. several tabs)
+     * do not each round-trip the proxy. Both the originator and joiners
+     * receive `{ status: 'coalesced', ... }` for the joined result — the
+     * outer contract does not distinguish who started the request, only that
+     * one upstream capture was made.
+     *
+     * Never throws for expected outcomes. Transport failures (5xx, 4xx other
+     * than 410) propagate as {@link PlatformApiError}; a 410 is normalized
+     * to a skip as described above.
+     */
+    captureCheckpoint(): Promise<CaptureCheckpointResult>;
+    /**
+     * The single `POST /checkpoint` attempt behind {@link captureCheckpoint}.
+     *
+     * Split out so the coalescing wrapper can install a shared in-flight
+     * promise without inlining the transport + response-mapping logic.
+     * Joined callers observe `{ status: 'coalesced', ... }` — the initiator
+     * sees the underlying `captured` / `coalesced` / `skipped` result the
+     * proxy returned. Both are legitimate: the OSS mirror uses the same
+     * "initiator sees the truth, joiners see coalesced" split.
+     */
+    private _doCaptureCheckpoint;
+    /**
+     * Clear local state that would otherwise let the caller keep exec'ing
+     * against a sandbox the upstream has already destroyed. Mirrors what
+     * `destroy()` does minus the outbound DELETE — the sandbox is already
+     * gone, so all that remains is to stop pointing at it.
+     *
+     * Also resets `status` to `'pending'` so a subsequent `_start()` on this
+     * reused instance re-runs provisioning instead of short-circuiting on
+     * the cached `'running'` state (see `MastraSandbox._start`).
+     */
+    private _clearDestroyedState;
+    /**
+     * Execute a command on the remote sandbox.
+     *
+     * `command` is a **shell string**: it is concatenated verbatim into the
+     * command line sent to the remote shell, which lets callers use pipes,
+     * redirects, and chaining (`ls -la | grep foo`). This matches the contract
+     * of {@link MastraSandbox} and the local sandbox implementation.
+     *
+     * `args`, when provided, are always shell-quoted so they cannot inject
+     * additional shell syntax.
+     *
+     * Security: callers MUST NOT pass untrusted input as `command`. If any part
+     * of the invocation is derived from an untrusted source, pass it through
+     * `args` (which is safely quoted) or shell-quote it yourself before
+     * inclusion. Untrusted `command` values allow arbitrary shell syntax
+     * execution on the remote sandbox.
+     */
+    executeCommand(command: string, args?: string[], options?: ExecuteCommandOptions): Promise<CommandResult>;
+    /**
+     * Run a single exec against the direct-exec transport, with one in-flight
+     * retry on WebSocket transport failure (socket closed without an `exit`
+     * frame and the exec did not time out). The retry mints a fresh lease
+     * — the failure could be a stale JWT — and reopens a new WebSocket.
+     *
+     * Error taxonomy:
+     * - **410 on `/exec-lease`** (either attempt) → the sandbox is gone.
+     *   Nulls the cached `_lease` and `_sandboxId` and throws
+     *   {@link SandboxDestroyedError}. Callers (typically `SandboxFleet`) must
+     *   catch this, clear the stale binding, and reprovision + replay.
+     * - **Persistent transport failure** (both WS attempts close without an
+     *   `exit` frame against a live sandbox) → {@link SandboxExecTransportError}
+     *   with WebSocket close diagnostics.
+     * - **Other `PlatformApiError`s** (404/500/501) propagate directly.
+     * - **Real command result** (exit code from Railway's exit frame, or
+     *   `timedOut: true`) returns normally.
+     *
+     * Returns a result with a real `exitCode` OR `timedOut: true`. Never
+     * returns `{ exitCode: null, timedOut: false }` — that case throws.
+     */
+    private _runDirectExec;
+    /**
+     * Try to run the exec against the in-sandbox sidecar over Railway's private
+     * network. Returns the result on success (including non-zero exit codes and
+     * timeouts — those are real command results, not failures). Returns
+     * `undefined` when the caller should fall back to the lease path:
+     *
+     * - Transport failure (connection refused, mid-stream drop, no `exit`
+     *   frame). The registry entry is evicted so subsequent execs skip the
+     *   private-net dial until the sidecar re-registers.
+     * - Sidecar answered with a non-2xx HTTP status. Registry is left intact —
+     *   the address is still valid; something else is wrong (bad request,
+     *   sidecar bug). Only this specific exec falls back.
+     */
+    private _tryExecViaPrivateNetwork;
+    /**
+     * Evict this sandbox's entry from the address registry after an observed
+     * transport failure. The entry stays gone until the next start() re-reads
+     * `instanceUrl` from a workspace-proxy response — until then, execs skip
+     * the private-net dial and go straight to the lease path.
+     */
+    private _invalidateAddress;
+    /**
+     * Return a cached exec lease, minting a fresh one when the cache is empty
+     * or the JWT is within {@link LEASE_REFRESH_MARGIN_MS} of `expiresAt`.
+     *
+     * Callers are expected to be on the "sandbox is running" path; we don't
+     * re-check `_sandboxId` here because `executeCommand` already gated on it.
+     */
+    private _ensureLease;
+    getInfo(): Promise<SandboxInfo>;
+    getInstructions(opts?: {
+        requestContext?: RequestContext;
+    }): string;
+}
+export {};
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../src/sandbox.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@mastra/platform-workspace",
+  "version": "0.0.0-esbuild-bundle-worker-20260807173433",
+  "description": "Mastra Platform workspace sandbox and filesystem providers",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "22.20.1",
+    "@vitest/coverage-v8": "4.1.10",
+    "@vitest/ui": "4.1.10",
+    "eslint": "^10.4.1",
+    "tsdown": "0.22.9",
+    "typescript": "^6.0.3",
+    "vitest": "4.1.10",
+    "@internal/lint": "0.0.0-esbuild-bundle-worker-20260807173433",
+    "@internal/types-builder": "0.0.0-esbuild-bundle-worker-20260807173433",
+    "@mastra/core": "0.0.0-esbuild-bundle-worker-20260807173433"
+  },
+  "peerDependencies": {
+    "@mastra/core": "0.0.0-esbuild-bundle-worker-20260807173433"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "homepage": "https://mastra.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mastra-ai/mastra.git",
+    "directory": "workspaces/platform-workspace"
+  },
+  "bugs": {
+    "url": "https://github.com/mastra-ai/mastra/issues"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "scripts": {
+    "build": "tsdown --silent --config tsdown.config.ts",
+    "build:lib": "pnpm build",
+    "build:watch": "pnpm build --watch",
+    "test:unit": "vitest run --exclude '**/*.integration.test.ts'",
+    "test:cloud": "vitest run --passWithNoTests ./src/**/*.integration.test.ts",
+    "test:watch": "vitest watch",
+    "test": "pnpm test:unit",
+    "lint": "oxlint . && eslint .",
+    "lint:fix": "oxlint --fix . && eslint --fix ."
+  }
+}