@mastra/platform-workspace 0.2.1 → 0.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +30 -0
- package/dist/direct-exec.d.ts +89 -0
- package/dist/direct-exec.d.ts.map +1 -0
- package/dist/index.cjs +921 -600
- package/dist/index.cjs.map +1 -1
- package/dist/index.js +892 -589
- package/dist/index.js.map +1 -1
- package/dist/sandbox.d.ts +42 -0
- package/dist/sandbox.d.ts.map +1 -1
- package/package.json +6 -6
package/dist/index.cjs
CHANGED
|
@@ -1,643 +1,964 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
var
|
|
4
|
-
var
|
|
5
|
-
var
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
var
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
1
|
+
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
2
|
+
//#region \0rolldown/runtime.js
|
|
3
|
+
var __create = Object.create;
|
|
4
|
+
var __defProp = Object.defineProperty;
|
|
5
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
6
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
7
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
8
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
9
|
+
var __copyProps = (to, from, except, desc) => {
|
|
10
|
+
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
|
|
11
|
+
key = keys[i];
|
|
12
|
+
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
|
|
13
|
+
get: ((k) => from[k]).bind(null, key),
|
|
14
|
+
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
15
|
+
});
|
|
16
|
+
}
|
|
17
|
+
return to;
|
|
18
|
+
};
|
|
19
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
|
|
20
|
+
value: mod,
|
|
21
|
+
enumerable: true
|
|
22
|
+
}) : target, mod));
|
|
23
|
+
//#endregion
|
|
24
|
+
let buffer = require("buffer");
|
|
25
|
+
let path = require("path");
|
|
26
|
+
path = __toESM(path, 1);
|
|
27
|
+
let _mastra_core_workspace = require("@mastra/core/workspace");
|
|
28
|
+
//#region src/client.ts
|
|
29
|
+
const DEFAULT_PROXY_URL = "https://workspaces.mastra.ai";
|
|
30
|
+
/**
|
|
31
|
+
* Default per-request timeout for calls to the workspace proxy. Applied only
|
|
32
|
+
* when the caller doesn't already pass an `AbortSignal`. Long-running routes
|
|
33
|
+
* (e.g. `POST /sandbox/:id/exec`) pass their own longer signal.
|
|
34
|
+
*/
|
|
35
|
+
const DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
|
|
14
36
|
function requireOption(value, name) {
|
|
15
|
-
|
|
16
|
-
|
|
37
|
+
if (!value) throw new Error(`${name} is required`);
|
|
38
|
+
return value;
|
|
17
39
|
}
|
|
18
40
|
function resolvePlatformOptions(options) {
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
projectId: requireOption(options.projectId ?? process.env.MASTRA_PROJECT_ID, "projectId"),
|
|
26
|
-
proxyUrl: (process.env.MASTRA_WORKSPACE_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/$/, ""),
|
|
27
|
-
fetch: options.fetch ?? fetch
|
|
28
|
-
};
|
|
41
|
+
return {
|
|
42
|
+
accessToken: requireOption(options.accessToken ?? process.env.MASTRA_PLATFORM_SECRET_KEY ?? process.env.MASTRA_PLATFORM_ACCESS_TOKEN, "accessToken"),
|
|
43
|
+
projectId: requireOption(options.projectId ?? process.env.MASTRA_PROJECT_ID, "projectId"),
|
|
44
|
+
proxyUrl: (process.env.MASTRA_WORKSPACE_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/$/, ""),
|
|
45
|
+
fetch: options.fetch ?? fetch
|
|
46
|
+
};
|
|
29
47
|
}
|
|
30
48
|
function parseProxyError(body) {
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
49
|
+
if (!body) return void 0;
|
|
50
|
+
let parsed;
|
|
51
|
+
try {
|
|
52
|
+
parsed = JSON.parse(body);
|
|
53
|
+
} catch {
|
|
54
|
+
return;
|
|
55
|
+
}
|
|
56
|
+
if (typeof parsed !== "object" || parsed === null) return void 0;
|
|
57
|
+
const err = parsed.error;
|
|
58
|
+
if (typeof err !== "object" || err === null) return void 0;
|
|
59
|
+
const { message, type } = err;
|
|
60
|
+
if (typeof message !== "string" || typeof type !== "string") return void 0;
|
|
61
|
+
return {
|
|
62
|
+
message,
|
|
63
|
+
type
|
|
64
|
+
};
|
|
44
65
|
}
|
|
45
66
|
var PlatformApiError = class extends Error {
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
67
|
+
status;
|
|
68
|
+
body;
|
|
69
|
+
/** Machine-readable proxy error kind (e.g. `not_found`), when the response body matches `{ error: { message, type } }`. */
|
|
70
|
+
code;
|
|
71
|
+
/** Human-readable proxy error message, when the response body matches `{ error: { message, type } }`. */
|
|
72
|
+
proxyMessage;
|
|
73
|
+
constructor(status, body) {
|
|
74
|
+
const parsed = parseProxyError(body);
|
|
75
|
+
const summary = parsed ? `${parsed.type}: ${parsed.message}` : body;
|
|
76
|
+
super(`Platform proxy request failed with ${status}${summary ? `: ${summary}` : ""}`);
|
|
77
|
+
this.name = "PlatformApiError";
|
|
78
|
+
this.status = status;
|
|
79
|
+
this.body = body;
|
|
80
|
+
this.code = parsed?.type;
|
|
81
|
+
this.proxyMessage = parsed?.message;
|
|
82
|
+
}
|
|
62
83
|
};
|
|
63
84
|
var PlatformClient = class {
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
85
|
+
accessToken;
|
|
86
|
+
projectId;
|
|
87
|
+
proxyUrl;
|
|
88
|
+
fetch;
|
|
89
|
+
constructor(options) {
|
|
90
|
+
const resolved = resolvePlatformOptions(options);
|
|
91
|
+
this.accessToken = resolved.accessToken;
|
|
92
|
+
this.projectId = resolved.projectId;
|
|
93
|
+
this.proxyUrl = resolved.proxyUrl;
|
|
94
|
+
this.fetch = resolved.fetch;
|
|
95
|
+
}
|
|
96
|
+
async request(path, options = {}) {
|
|
97
|
+
const url = new URL(`${this.proxyUrl}/v1/projects/${encodeURIComponent(this.projectId)}${path}`);
|
|
98
|
+
for (const [key, value] of Object.entries(options.query ?? {})) if (value !== void 0) url.searchParams.set(key, String(value));
|
|
99
|
+
const headers = new Headers(options.headers);
|
|
100
|
+
headers.set("authorization", `Bearer ${this.accessToken}`);
|
|
101
|
+
const { query: _query, ...fetchOptions } = options;
|
|
102
|
+
const signal = fetchOptions.signal ?? AbortSignal.timeout(DEFAULT_REQUEST_TIMEOUT_MS);
|
|
103
|
+
const response = await this.fetch(url, {
|
|
104
|
+
...fetchOptions,
|
|
105
|
+
headers,
|
|
106
|
+
signal
|
|
107
|
+
});
|
|
108
|
+
if (!response.ok) throw new PlatformApiError(response.status, await response.text());
|
|
109
|
+
return response;
|
|
110
|
+
}
|
|
90
111
|
};
|
|
112
|
+
//#endregion
|
|
113
|
+
//#region src/filesystem.ts
|
|
91
114
|
function normalizePath(input) {
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
115
|
+
if (!input || input === ".") return "/";
|
|
116
|
+
let normalized = input.startsWith("/") ? input : `/${input}`;
|
|
117
|
+
normalized = path.default.posix.normalize(normalized);
|
|
118
|
+
return normalized === "." ? "/" : normalized;
|
|
96
119
|
}
|
|
97
|
-
function keyFromPath(path) {
|
|
98
|
-
|
|
99
|
-
|
|
120
|
+
function keyFromPath(path$1) {
|
|
121
|
+
const normalized = normalizePath(path$1);
|
|
122
|
+
return normalized === "/" ? "" : normalized.slice(1);
|
|
100
123
|
}
|
|
124
|
+
/**
|
|
125
|
+
* Encode each `/`-delimited segment of an object key with `encodeURIComponent`
|
|
126
|
+
* so reserved URL characters (`?`, `#`, `%`, `&`, `+`, spaces, etc.) are
|
|
127
|
+
* treated as part of the key instead of URL syntax. Kept segment-aware so
|
|
128
|
+
* `/` continues to act as a path separator on the wire.
|
|
129
|
+
*/
|
|
101
130
|
function encodeKeyPath(key) {
|
|
102
|
-
|
|
131
|
+
return key.split("/").map(encodeURIComponent).join("/");
|
|
103
132
|
}
|
|
104
|
-
function nameFromPath(path) {
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
133
|
+
function nameFromPath(path$2) {
|
|
134
|
+
const normalized = normalizePath(path$2);
|
|
135
|
+
if (normalized === "/") return "";
|
|
136
|
+
return normalized.slice(normalized.lastIndexOf("/") + 1);
|
|
108
137
|
}
|
|
109
138
|
function contentToBody(content) {
|
|
110
|
-
|
|
111
|
-
|
|
139
|
+
if (typeof content === "string") return content;
|
|
140
|
+
return buffer.Buffer.from(content);
|
|
112
141
|
}
|
|
113
142
|
function headerDate(headers, name) {
|
|
114
|
-
|
|
115
|
-
|
|
143
|
+
const value = headers.get(name);
|
|
144
|
+
return value ? new Date(value) : /* @__PURE__ */ new Date(0);
|
|
116
145
|
}
|
|
117
146
|
function headerSize(headers) {
|
|
118
|
-
|
|
119
|
-
|
|
147
|
+
const value = headers.get("content-length");
|
|
148
|
+
return value ? Number(value) : 0;
|
|
120
149
|
}
|
|
121
150
|
function isNotFound(error) {
|
|
122
|
-
|
|
151
|
+
return typeof error === "object" && error !== null && "status" in error && error.status === 404;
|
|
123
152
|
}
|
|
124
|
-
var PlatformFilesystem = class extends
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
getInfo() {
|
|
328
|
-
return {
|
|
329
|
-
id: this.id,
|
|
330
|
-
name: this.name,
|
|
331
|
-
provider: this.provider,
|
|
332
|
-
status: this.status,
|
|
333
|
-
readOnly: this.readOnly,
|
|
334
|
-
icon: this.icon,
|
|
335
|
-
metadata: {
|
|
336
|
-
bucketName: this._bucketName,
|
|
337
|
-
...this.displayName && { displayName: this.displayName },
|
|
338
|
-
...this.description && { description: this.description }
|
|
339
|
-
}
|
|
340
|
-
};
|
|
341
|
-
}
|
|
153
|
+
var PlatformFilesystem = class extends _mastra_core_workspace.MastraFilesystem {
|
|
154
|
+
id;
|
|
155
|
+
name = "PlatformFilesystem";
|
|
156
|
+
provider = "platform";
|
|
157
|
+
readOnly;
|
|
158
|
+
displayName;
|
|
159
|
+
icon;
|
|
160
|
+
description;
|
|
161
|
+
status = "pending";
|
|
162
|
+
_client;
|
|
163
|
+
_bucketName;
|
|
164
|
+
_instructionsOverride;
|
|
165
|
+
constructor(options = {}) {
|
|
166
|
+
super({
|
|
167
|
+
...options,
|
|
168
|
+
name: "PlatformFilesystem"
|
|
169
|
+
});
|
|
170
|
+
this.id = options.id ?? this.generateId();
|
|
171
|
+
this._bucketName = options.bucketName ?? process.env.MASTRA_PLATFORM_BUCKET_NAME ?? "";
|
|
172
|
+
if (!this._bucketName) throw new Error("bucketName is required");
|
|
173
|
+
this.readOnly = options.readOnly;
|
|
174
|
+
this.displayName = options.displayName;
|
|
175
|
+
this.icon = options.icon ?? "cloud";
|
|
176
|
+
this.description = options.description;
|
|
177
|
+
this._instructionsOverride = options.instructions;
|
|
178
|
+
this._client = new PlatformClient(options);
|
|
179
|
+
}
|
|
180
|
+
generateId() {
|
|
181
|
+
return `platform-fs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
|
|
182
|
+
}
|
|
183
|
+
async readFile(path$3, options) {
|
|
184
|
+
await this.ensureReady();
|
|
185
|
+
let response;
|
|
186
|
+
try {
|
|
187
|
+
response = await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(path$3))}`);
|
|
188
|
+
} catch (error) {
|
|
189
|
+
if (isNotFound(error)) throw new _mastra_core_workspace.FileNotFoundError(path$3);
|
|
190
|
+
throw error;
|
|
191
|
+
}
|
|
192
|
+
const buffer$1 = buffer.Buffer.from(await response.arrayBuffer());
|
|
193
|
+
return options?.encoding ? buffer$1.toString(options.encoding) : buffer$1;
|
|
194
|
+
}
|
|
195
|
+
async writeFile(path$4, content, options) {
|
|
196
|
+
await this.ensureReady();
|
|
197
|
+
if (this.readOnly) throw new _mastra_core_workspace.WorkspaceReadOnlyError("writeFile");
|
|
198
|
+
const headers = {};
|
|
199
|
+
if (options?.mimeType) headers["content-type"] = options.mimeType;
|
|
200
|
+
if (options?.overwrite === false) headers["if-none-match"] = "*";
|
|
201
|
+
try {
|
|
202
|
+
await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(path$4))}`, {
|
|
203
|
+
method: "PUT",
|
|
204
|
+
headers,
|
|
205
|
+
body: contentToBody(content)
|
|
206
|
+
});
|
|
207
|
+
} catch (error) {
|
|
208
|
+
if (typeof error === "object" && error !== null && "status" in error && error.status === 412) throw new _mastra_core_workspace.FileExistsError(path$4);
|
|
209
|
+
throw error;
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
/**
|
|
213
|
+
* Append bytes to a file.
|
|
214
|
+
*
|
|
215
|
+
* **Not atomic.** Object storage behind the workspace proxy has no native
|
|
216
|
+
* append or compare-and-swap primitive, so this implementation is a
|
|
217
|
+
* read-modify-write: it reads the current contents, concatenates the new
|
|
218
|
+
* bytes, and PUTs the whole object back. Concurrent `appendFile` calls to
|
|
219
|
+
* the same path can overwrite each other's writes ("last write wins").
|
|
220
|
+
* Use `writeFile` with distinct keys for concurrent writers.
|
|
221
|
+
*/
|
|
222
|
+
async appendFile(path$5, content) {
|
|
223
|
+
const existing = await this.exists(path$5) ? await this.readFile(path$5) : buffer.Buffer.alloc(0);
|
|
224
|
+
await this.writeFile(path$5, buffer.Buffer.concat([buffer.Buffer.isBuffer(existing) ? existing : buffer.Buffer.from(existing), buffer.Buffer.from(content)]));
|
|
225
|
+
}
|
|
226
|
+
async deleteFile(path$6, options) {
|
|
227
|
+
await this.ensureReady();
|
|
228
|
+
if (this.readOnly) throw new _mastra_core_workspace.WorkspaceReadOnlyError("deleteFile");
|
|
229
|
+
try {
|
|
230
|
+
await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(path$6))}`, {
|
|
231
|
+
method: "DELETE",
|
|
232
|
+
query: { recursive: options?.recursive }
|
|
233
|
+
});
|
|
234
|
+
} catch (error) {
|
|
235
|
+
if (isNotFound(error) && options?.force) return;
|
|
236
|
+
if (isNotFound(error)) throw new _mastra_core_workspace.FileNotFoundError(path$6);
|
|
237
|
+
throw error;
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
async copyFile(src, dest, options) {
|
|
241
|
+
await this.ensureReady();
|
|
242
|
+
if (this.readOnly) throw new _mastra_core_workspace.WorkspaceReadOnlyError("copyFile");
|
|
243
|
+
if (options?.overwrite === false) throw new Error("PlatformFilesystem.copyFile does not support overwrite: false — the proxy always overwrites.");
|
|
244
|
+
await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(src))}`, {
|
|
245
|
+
method: "POST",
|
|
246
|
+
query: { op: "copy" },
|
|
247
|
+
headers: { "content-type": "application/json" },
|
|
248
|
+
body: JSON.stringify({ destination: keyFromPath(dest) })
|
|
249
|
+
});
|
|
250
|
+
}
|
|
251
|
+
async moveFile(src, dest, options) {
|
|
252
|
+
await this.ensureReady();
|
|
253
|
+
if (this.readOnly) throw new _mastra_core_workspace.WorkspaceReadOnlyError("moveFile");
|
|
254
|
+
if (options?.overwrite === false) throw new Error("PlatformFilesystem.moveFile does not support overwrite: false — the proxy always overwrites.");
|
|
255
|
+
await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(src))}`, {
|
|
256
|
+
method: "POST",
|
|
257
|
+
query: { op: "rename" },
|
|
258
|
+
headers: { "content-type": "application/json" },
|
|
259
|
+
body: JSON.stringify({ destination: keyFromPath(dest) })
|
|
260
|
+
});
|
|
261
|
+
}
|
|
262
|
+
async mkdir(path$7, _options) {
|
|
263
|
+
await this.ensureReady();
|
|
264
|
+
if (this.readOnly) throw new _mastra_core_workspace.WorkspaceReadOnlyError("mkdir");
|
|
265
|
+
await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(path$7))}`, {
|
|
266
|
+
method: "POST",
|
|
267
|
+
query: { op: "mkdir" }
|
|
268
|
+
});
|
|
269
|
+
}
|
|
270
|
+
async rmdir(path$8, options) {
|
|
271
|
+
await this.deleteFile(path$8.endsWith("/") ? path$8 : `${path$8}/`, {
|
|
272
|
+
recursive: true,
|
|
273
|
+
force: options?.force
|
|
274
|
+
});
|
|
275
|
+
}
|
|
276
|
+
async readdir(path$9, options) {
|
|
277
|
+
await this.ensureReady();
|
|
278
|
+
const prefix = keyFromPath(path$9);
|
|
279
|
+
const json = await (await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(prefix)}`, { query: {
|
|
280
|
+
delimiter: options?.recursive ? void 0 : "/",
|
|
281
|
+
prefix: prefix ? `${prefix.replace(/\/$/, "")}/` : void 0
|
|
282
|
+
} })).json();
|
|
283
|
+
return [...(json.commonPrefixes ?? []).map((prefix) => ({
|
|
284
|
+
name: nameFromPath(prefix.replace(/\/$/, "")),
|
|
285
|
+
type: "directory"
|
|
286
|
+
})), ...(json.contents ?? []).filter((object) => object.key && !object.key.endsWith("/")).map((object) => ({
|
|
287
|
+
name: nameFromPath(object.key),
|
|
288
|
+
type: "file",
|
|
289
|
+
size: object.size
|
|
290
|
+
}))].filter((entry) => !options?.extension || entry.type === "directory" || matchesExtension(entry.name, options.extension));
|
|
291
|
+
}
|
|
292
|
+
async exists(path$10) {
|
|
293
|
+
try {
|
|
294
|
+
await this.stat(path$10);
|
|
295
|
+
return true;
|
|
296
|
+
} catch (error) {
|
|
297
|
+
if (isNotFound(error) || error instanceof _mastra_core_workspace.FileNotFoundError) return false;
|
|
298
|
+
throw error;
|
|
299
|
+
}
|
|
300
|
+
}
|
|
301
|
+
async stat(path$11) {
|
|
302
|
+
await this.ensureReady();
|
|
303
|
+
const normalized = normalizePath(path$11);
|
|
304
|
+
if (normalized === "/") return {
|
|
305
|
+
name: "",
|
|
306
|
+
path: "/",
|
|
307
|
+
type: "directory",
|
|
308
|
+
size: 0,
|
|
309
|
+
createdAt: /* @__PURE__ */ new Date(0),
|
|
310
|
+
modifiedAt: /* @__PURE__ */ new Date(0)
|
|
311
|
+
};
|
|
312
|
+
let response;
|
|
313
|
+
try {
|
|
314
|
+
response = await this._client.request(`/fs/${encodeURIComponent(this._bucketName)}/${encodeKeyPath(keyFromPath(path$11))}`, { method: "HEAD" });
|
|
315
|
+
} catch (error) {
|
|
316
|
+
if (isNotFound(error)) throw new _mastra_core_workspace.FileNotFoundError(path$11);
|
|
317
|
+
throw error;
|
|
318
|
+
}
|
|
319
|
+
return {
|
|
320
|
+
name: nameFromPath(path$11),
|
|
321
|
+
path: normalized,
|
|
322
|
+
type: normalized.endsWith("/") ? "directory" : "file",
|
|
323
|
+
size: headerSize(response.headers),
|
|
324
|
+
createdAt: headerDate(response.headers, "last-modified"),
|
|
325
|
+
modifiedAt: headerDate(response.headers, "last-modified"),
|
|
326
|
+
mimeType: response.headers.get("content-type") ?? void 0
|
|
327
|
+
};
|
|
328
|
+
}
|
|
329
|
+
realpath(path$12) {
|
|
330
|
+
return Promise.resolve(normalizePath(path$12));
|
|
331
|
+
}
|
|
332
|
+
getInstructions(opts) {
|
|
333
|
+
const defaultInstructions = `Platform filesystem backed by Mastra Platform bucket ${this._bucketName}. Use absolute workspace paths.`;
|
|
334
|
+
if (typeof this._instructionsOverride === "function") return this._instructionsOverride({
|
|
335
|
+
defaultInstructions,
|
|
336
|
+
requestContext: opts?.requestContext
|
|
337
|
+
});
|
|
338
|
+
if (typeof this._instructionsOverride === "string") return this._instructionsOverride;
|
|
339
|
+
return defaultInstructions;
|
|
340
|
+
}
|
|
341
|
+
getInfo() {
|
|
342
|
+
return {
|
|
343
|
+
id: this.id,
|
|
344
|
+
name: this.name,
|
|
345
|
+
provider: this.provider,
|
|
346
|
+
status: this.status,
|
|
347
|
+
readOnly: this.readOnly,
|
|
348
|
+
icon: this.icon,
|
|
349
|
+
metadata: {
|
|
350
|
+
bucketName: this._bucketName,
|
|
351
|
+
...this.displayName && { displayName: this.displayName },
|
|
352
|
+
...this.description && { description: this.description }
|
|
353
|
+
}
|
|
354
|
+
};
|
|
355
|
+
}
|
|
342
356
|
};
|
|
343
357
|
function matchesExtension(name, extension) {
|
|
344
|
-
|
|
345
|
-
return extensions.some((ext) => name.endsWith(ext));
|
|
358
|
+
return (Array.isArray(extension) ? extension : [extension]).some((ext) => name.endsWith(ext));
|
|
346
359
|
}
|
|
360
|
+
//#endregion
|
|
361
|
+
//#region src/direct-exec.ts
|
|
362
|
+
/**
|
|
363
|
+
* Direct exec client — opens Railway's tcp-proxy exec WebSocket directly using
|
|
364
|
+
* a short-lived JWT minted by the workspace proxy's exec-lease endpoint. This
|
|
365
|
+
* removes the platform data plane from the exec stdout/stderr path entirely
|
|
366
|
+
* (see `docs/factory/direct-sandbox-connection.md` in the Platform repo),
|
|
367
|
+
* cutting payload-scaled Cloud Run egress and RTT for commands like
|
|
368
|
+
* `pnpm install` that stream tens of MB of output.
|
|
369
|
+
*
|
|
370
|
+
* The frame protocol below mirrors `connectExecWs()` in `railway@3.5.5`
|
|
371
|
+
* (`workspaces/railway/node_modules/railway/dist/index.js`). The `railway`
|
|
372
|
+
* SDK's version is pinned on both sides (platform + here); a version bump
|
|
373
|
+
* signals the protocol may have drifted and this module must be revisited.
|
|
374
|
+
*/
|
|
375
|
+
/** Byte-0 tag on binary WS frames for stdout output. */
|
|
376
|
+
const STDOUT_FRAME = 1;
|
|
377
|
+
/** Byte-0 tag on binary WS frames for stderr output. */
|
|
378
|
+
const STDERR_FRAME = 3;
|
|
379
|
+
/**
|
|
380
|
+
* Upper bound on how long we'll wait for the WebSocket to open when the
|
|
381
|
+
* caller didn't supply a `timeoutMs`. Guards against a stalled TLS/WS
|
|
382
|
+
* handshake leaving the promise unresolved forever. Not applied once the
|
|
383
|
+
* socket has opened — a caller with no timeout has opted in to unbounded
|
|
384
|
+
* command runtime, just not to unbounded connection setup.
|
|
385
|
+
*/
|
|
386
|
+
const HANDSHAKE_DEADLINE_MS = 3e4;
|
|
387
|
+
const DEFAULT_WS_FACTORY = (endpoint, subprotocols) => {
|
|
388
|
+
const WS = globalThis.WebSocket;
|
|
389
|
+
if (!WS) throw new Error("Direct exec requires a WebSocket implementation. Node 22+ provides one globally; on older runtimes, pass webSocketFactory explicitly.");
|
|
390
|
+
return new WS(endpoint, subprotocols);
|
|
391
|
+
};
|
|
392
|
+
/**
|
|
393
|
+
* Open the provider exec WebSocket using `lease`, run `command`, and resolve
|
|
394
|
+
* with the accumulated stdout/stderr + exit code. See the module docstring
|
|
395
|
+
* for the wire protocol reference.
|
|
396
|
+
*
|
|
397
|
+
* The client sends `stdin_close` immediately after `init_exec`, matching the
|
|
398
|
+
* SDK's own one-shot exec behavior — we never stream stdin from the caller.
|
|
399
|
+
*/
|
|
400
|
+
function execViaLease(lease, options) {
|
|
401
|
+
const factory = options.webSocketFactory ?? DEFAULT_WS_FACTORY;
|
|
402
|
+
const stdoutDecoder = new TextDecoder();
|
|
403
|
+
const stderrDecoder = new TextDecoder();
|
|
404
|
+
return new Promise((resolve) => {
|
|
405
|
+
let stdout = "";
|
|
406
|
+
let stderr = "";
|
|
407
|
+
let exitCode = null;
|
|
408
|
+
let timedOut = false;
|
|
409
|
+
let settled = false;
|
|
410
|
+
let opened = false;
|
|
411
|
+
let timer;
|
|
412
|
+
let handshakeTimer;
|
|
413
|
+
const settle = () => {
|
|
414
|
+
if (settled) return;
|
|
415
|
+
settled = true;
|
|
416
|
+
if (timer) clearTimeout(timer);
|
|
417
|
+
if (handshakeTimer) clearTimeout(handshakeTimer);
|
|
418
|
+
const stdoutTail = stdoutDecoder.decode();
|
|
419
|
+
if (stdoutTail) {
|
|
420
|
+
stdout += stdoutTail;
|
|
421
|
+
options.onStdout?.(stdoutTail);
|
|
422
|
+
}
|
|
423
|
+
const stderrTail = stderrDecoder.decode();
|
|
424
|
+
if (stderrTail) {
|
|
425
|
+
stderr += stderrTail;
|
|
426
|
+
options.onStderr?.(stderrTail);
|
|
427
|
+
}
|
|
428
|
+
try {
|
|
429
|
+
socket.close(1e3, "");
|
|
430
|
+
} catch {}
|
|
431
|
+
resolve({
|
|
432
|
+
exitCode,
|
|
433
|
+
stdout,
|
|
434
|
+
stderr,
|
|
435
|
+
truncated: false,
|
|
436
|
+
timedOut
|
|
437
|
+
});
|
|
438
|
+
};
|
|
439
|
+
if (options.timeoutMs !== void 0 && options.timeoutMs > 0) timer = setTimeout(() => {
|
|
440
|
+
timedOut = true;
|
|
441
|
+
if (exitCode === null) exitCode = 124;
|
|
442
|
+
settle();
|
|
443
|
+
}, options.timeoutMs);
|
|
444
|
+
else handshakeTimer = setTimeout(() => {
|
|
445
|
+
if (!opened) settle();
|
|
446
|
+
}, HANDSHAKE_DEADLINE_MS);
|
|
447
|
+
const socket = factory(lease.wsEndpoint, [lease.subprotocol, lease.jwt]);
|
|
448
|
+
socket.binaryType = "arraybuffer";
|
|
449
|
+
socket.onopen = () => {
|
|
450
|
+
opened = true;
|
|
451
|
+
if (handshakeTimer) {
|
|
452
|
+
clearTimeout(handshakeTimer);
|
|
453
|
+
handshakeTimer = void 0;
|
|
454
|
+
}
|
|
455
|
+
const data = { command: options.command };
|
|
456
|
+
if (options.cwd) data.cwd = options.cwd;
|
|
457
|
+
if (options.env && Object.keys(options.env).length > 0) data.env = options.env;
|
|
458
|
+
socket.send(JSON.stringify({
|
|
459
|
+
type: "init_exec",
|
|
460
|
+
data
|
|
461
|
+
}));
|
|
462
|
+
socket.send(JSON.stringify({ type: "stdin_close" }));
|
|
463
|
+
};
|
|
464
|
+
socket.onmessage = (event) => {
|
|
465
|
+
const { data } = event;
|
|
466
|
+
if (data instanceof ArrayBuffer) handleBinaryFrame(data);
|
|
467
|
+
else if (typeof data === "string") handleTextFrame(data);
|
|
468
|
+
};
|
|
469
|
+
socket.onclose = (event) => {
|
|
470
|
+
if (!opened) {
|
|
471
|
+
settle();
|
|
472
|
+
return;
|
|
473
|
+
}
|
|
474
|
+
settle();
|
|
475
|
+
};
|
|
476
|
+
socket.onerror = () => {
|
|
477
|
+
if (settled) return;
|
|
478
|
+
if (!opened) settle();
|
|
479
|
+
};
|
|
480
|
+
function handleBinaryFrame(buffer) {
|
|
481
|
+
const view = new Uint8Array(buffer);
|
|
482
|
+
if (view.length <= 1) return;
|
|
483
|
+
if (view[0] === STDOUT_FRAME) {
|
|
484
|
+
const chunk = stdoutDecoder.decode(view.subarray(1), { stream: true });
|
|
485
|
+
stdout += chunk;
|
|
486
|
+
options.onStdout?.(chunk);
|
|
487
|
+
} else if (view[0] === STDERR_FRAME) {
|
|
488
|
+
const chunk = stderrDecoder.decode(view.subarray(1), { stream: true });
|
|
489
|
+
stderr += chunk;
|
|
490
|
+
options.onStderr?.(chunk);
|
|
491
|
+
}
|
|
492
|
+
}
|
|
493
|
+
function handleTextFrame(text) {
|
|
494
|
+
let frame;
|
|
495
|
+
try {
|
|
496
|
+
frame = JSON.parse(text);
|
|
497
|
+
} catch {
|
|
498
|
+
return;
|
|
499
|
+
}
|
|
500
|
+
if (frame.type === "exit") {
|
|
501
|
+
exitCode = frame.data?.exit_code ?? 0;
|
|
502
|
+
settle();
|
|
503
|
+
}
|
|
504
|
+
}
|
|
505
|
+
});
|
|
506
|
+
}
|
|
507
|
+
//#endregion
|
|
508
|
+
//#region src/sandbox.ts
|
|
509
|
+
/**
|
|
510
|
+
* How long before a lease's stated `expiresAt` we should treat it as
|
|
511
|
+
* expired. Avoids a race where the JWT is valid at cache-hit time but the
|
|
512
|
+
* server rejects it by the time the WebSocket handshake completes.
|
|
513
|
+
*/
|
|
514
|
+
const LEASE_REFRESH_MARGIN_MS = 6e4;
|
|
515
|
+
/** Max attempts for `POST /sandbox` when the proxy returns transient 5xx errors. */
|
|
516
|
+
const CREATE_MAX_ATTEMPTS = 3;
|
|
517
|
+
/** Base delay between create retries; multiplied by the attempt number. */
|
|
518
|
+
const CREATE_RETRY_BASE_DELAY_MS = 2e3;
|
|
519
|
+
/**
|
|
520
|
+
* Compose a shell command line from a `command` string and optional `args`.
|
|
521
|
+
*
|
|
522
|
+
* IMPORTANT: `command` is treated as a **shell string** and passed to the
|
|
523
|
+
* remote shell verbatim so callers can use pipes, redirects, and chaining
|
|
524
|
+
* (`ls -la | grep foo`). This matches the contract of {@link MastraSandbox}
|
|
525
|
+
* and the local sandbox implementation. `args` are always shell-quoted so
|
|
526
|
+
* they cannot inject syntax.
|
|
527
|
+
*
|
|
528
|
+
* Callers MUST NOT pass untrusted input as `command`. Untrusted values must
|
|
529
|
+
* be passed via `args`, where they are safely quoted. Passing untrusted
|
|
530
|
+
* input as `command` allows arbitrary shell syntax execution on the remote
|
|
531
|
+
* sandbox.
|
|
532
|
+
*/
|
|
347
533
|
function buildCommand(command, args) {
|
|
348
|
-
|
|
534
|
+
return args?.length ? `${command} ${args.map(shellQuote).join(" ")}` : command;
|
|
349
535
|
}
|
|
350
536
|
function shellQuote(arg) {
|
|
351
|
-
|
|
352
|
-
|
|
537
|
+
if (/^[a-zA-Z0-9._\-/=:@]+$/.test(arg)) return arg;
|
|
538
|
+
return `'${arg.replace(/'/g, `'\\''`)}'`;
|
|
353
539
|
}
|
|
354
|
-
var PlatformProcessHandle = class extends
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
540
|
+
var PlatformProcessHandle = class extends _mastra_core_workspace.ProcessHandle {
|
|
541
|
+
pid;
|
|
542
|
+
resultPromise;
|
|
543
|
+
exitCodeValue;
|
|
544
|
+
constructor(pid, resultPromise, options) {
|
|
545
|
+
super(options);
|
|
546
|
+
this.pid = pid;
|
|
547
|
+
this.resultPromise = resultPromise.then((result) => {
|
|
548
|
+
this.exitCodeValue = result.exitCode;
|
|
549
|
+
if (result.stdout) this.emitStdout(result.stdout);
|
|
550
|
+
if (result.stderr) this.emitStderr(result.stderr);
|
|
551
|
+
return result;
|
|
552
|
+
});
|
|
553
|
+
}
|
|
554
|
+
get exitCode() {
|
|
555
|
+
return this.exitCodeValue;
|
|
556
|
+
}
|
|
557
|
+
async wait() {
|
|
558
|
+
return this.resultPromise;
|
|
559
|
+
}
|
|
560
|
+
async kill() {
|
|
561
|
+
throw new Error("Platform sandbox command execution does not support killing individual processes");
|
|
562
|
+
}
|
|
563
|
+
async sendStdin() {
|
|
564
|
+
throw new Error("Platform sandbox command execution does not support stdin");
|
|
565
|
+
}
|
|
380
566
|
};
|
|
381
|
-
var PlatformProcessManager = class extends
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
}));
|
|
404
|
-
}
|
|
567
|
+
var PlatformProcessManager = class extends _mastra_core_workspace.SandboxProcessManager {
|
|
568
|
+
spawnCounter = 0;
|
|
569
|
+
/**
|
|
570
|
+
* Spawn a process on the remote sandbox.
|
|
571
|
+
*
|
|
572
|
+
* `command` is interpreted as a shell string by the remote shell, matching
|
|
573
|
+
* the {@link MastraSandbox} contract. See {@link PlatformSandbox.executeCommand}
|
|
574
|
+
* for the untrusted-input caveat: never pass untrusted values as `command`.
|
|
575
|
+
*/
|
|
576
|
+
async spawn(command, options = {}) {
|
|
577
|
+
const handle = new PlatformProcessHandle(`platform-proc-${Date.now().toString(36)}-${(this.spawnCounter++).toString(36)}`, this.sandbox.executeCommand(command, void 0, options), options);
|
|
578
|
+
this._tracked.set(handle.pid, handle);
|
|
579
|
+
return handle;
|
|
580
|
+
}
|
|
581
|
+
async list() {
|
|
582
|
+
return Array.from(this._tracked.values()).map((handle) => ({
|
|
583
|
+
pid: handle.pid,
|
|
584
|
+
command: handle.command,
|
|
585
|
+
running: handle.exitCode === void 0,
|
|
586
|
+
...handle.exitCode !== void 0 && { exitCode: handle.exitCode }
|
|
587
|
+
}));
|
|
588
|
+
}
|
|
405
589
|
};
|
|
406
|
-
var PlatformSandbox = class
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
590
|
+
var PlatformSandbox = class PlatformSandbox extends _mastra_core_workspace.MastraSandbox {
|
|
591
|
+
id;
|
|
592
|
+
name = "PlatformSandbox";
|
|
593
|
+
provider = "platform";
|
|
594
|
+
status = "pending";
|
|
595
|
+
_client;
|
|
596
|
+
_environmentId;
|
|
597
|
+
_sandboxId;
|
|
598
|
+
_idleTimeoutMinutes;
|
|
599
|
+
_networkIsolation;
|
|
600
|
+
_env;
|
|
601
|
+
_timeout;
|
|
602
|
+
_instructionsOverride;
|
|
603
|
+
_createdAt = null;
|
|
604
|
+
_webSocketFactory;
|
|
605
|
+
/**
|
|
606
|
+
* Cached exec lease for this sandbox. `null` before the first exec and
|
|
607
|
+
* after {@link destroy}. Refreshed when `expiresAt - LEASE_REFRESH_MARGIN_MS < now`
|
|
608
|
+
* (see {@link _ensureLease}); a lease without a disclosed `expiresAt`
|
|
609
|
+
* is refreshed on every call.
|
|
610
|
+
*/
|
|
611
|
+
_lease = null;
|
|
612
|
+
/**
|
|
613
|
+
* In-flight mint request; concurrent `_ensureLease` callers on a cold or
|
|
614
|
+
* near-expiry cache all await this single promise so we don't burn N
|
|
615
|
+
* `POST /exec-lease` round-trips when the sandbox is doing N parallel execs.
|
|
616
|
+
* Cleared (regardless of success or failure) when the request settles.
|
|
617
|
+
*/
|
|
618
|
+
_leaseInFlight = null;
|
|
619
|
+
/**
|
|
620
|
+
* Tri-state feature detection for the platform's exec-lease endpoint:
|
|
621
|
+
* undefined — not yet tried (default; try direct on first exec)
|
|
622
|
+
* true — endpoint present, use direct exec
|
|
623
|
+
* false — endpoint returned 404 or 501, fall back permanently to /exec
|
|
624
|
+
* Sticky per instance so we make the fallback decision once per sandbox
|
|
625
|
+
* lifetime instead of paying an extra round-trip on every exec.
|
|
626
|
+
*/
|
|
627
|
+
_directExecAvailable = void 0;
|
|
628
|
+
constructor(options = {}) {
|
|
629
|
+
super({
|
|
630
|
+
...options,
|
|
631
|
+
name: "PlatformSandbox",
|
|
632
|
+
processes: new PlatformProcessManager()
|
|
633
|
+
});
|
|
634
|
+
this.id = options.id ?? this.generateId();
|
|
635
|
+
this._client = new PlatformClient(options);
|
|
636
|
+
this._environmentId = options.environmentId ?? process.env.MASTRA_ENVIRONMENT_ID ?? "";
|
|
637
|
+
if (!this._environmentId && !options.sandboxId) throw new Error("environmentId is required");
|
|
638
|
+
this._sandboxId = options.sandboxId;
|
|
639
|
+
this._idleTimeoutMinutes = options.idleTimeoutMinutes;
|
|
640
|
+
this._networkIsolation = options.networkIsolation;
|
|
641
|
+
this._env = options.env ?? {};
|
|
642
|
+
this._timeout = options.timeout;
|
|
643
|
+
this._instructionsOverride = options.instructions;
|
|
644
|
+
this._webSocketFactory = options.webSocketFactory;
|
|
645
|
+
}
|
|
646
|
+
generateId() {
|
|
647
|
+
return `platform-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
|
|
648
|
+
}
|
|
649
|
+
/**
|
|
650
|
+
* Construct a sibling {@link PlatformSandbox} that inherits this sandbox's
|
|
651
|
+
* credentials and defaults (access token, project, environment, network
|
|
652
|
+
* isolation, timeout, instructions, env, idle timeout) with per-instance
|
|
653
|
+
* overrides from `options`.
|
|
654
|
+
*
|
|
655
|
+
* Performs no I/O and does not require this sandbox to be started — the
|
|
656
|
+
* returned sandbox is not started and provisions (or reattaches, when
|
|
657
|
+
* `sandboxId` is set) on its own `start()`. Use it when one configured
|
|
658
|
+
* sandbox acts as the template for a fleet of independent sandboxes
|
|
659
|
+
* (e.g. one per project).
|
|
660
|
+
*/
|
|
661
|
+
clone(options = {}) {
|
|
662
|
+
return new PlatformSandbox({
|
|
663
|
+
...options.id !== void 0 && { id: options.id },
|
|
664
|
+
accessToken: this._client.accessToken,
|
|
665
|
+
projectId: this._client.projectId,
|
|
666
|
+
fetch: this._client.fetch,
|
|
667
|
+
environmentId: this._environmentId,
|
|
668
|
+
...options.sandboxId !== void 0 && { sandboxId: options.sandboxId },
|
|
669
|
+
idleTimeoutMinutes: options.idleTimeoutMinutes ?? this._idleTimeoutMinutes,
|
|
670
|
+
...this._networkIsolation !== void 0 && { networkIsolation: this._networkIsolation },
|
|
671
|
+
env: options.env ?? this._env,
|
|
672
|
+
...this._timeout !== void 0 && { timeout: this._timeout },
|
|
673
|
+
...this._instructionsOverride !== void 0 && { instructions: this._instructionsOverride },
|
|
674
|
+
...this._webSocketFactory !== void 0 && { webSocketFactory: this._webSocketFactory }
|
|
675
|
+
});
|
|
676
|
+
}
|
|
677
|
+
async start() {
|
|
678
|
+
if (this._sandboxId) try {
|
|
679
|
+
const json = await (await this._client.request(`/sandbox/${encodeURIComponent(this._sandboxId)}`)).json();
|
|
680
|
+
if (!json.destroyedAt) {
|
|
681
|
+
this._createdAt = json.createdAt ? new Date(json.createdAt) : /* @__PURE__ */ new Date();
|
|
682
|
+
return;
|
|
683
|
+
}
|
|
684
|
+
this._sandboxId = void 0;
|
|
685
|
+
} catch (error) {
|
|
686
|
+
if (!(error instanceof PlatformApiError) || error.status !== 404) throw error;
|
|
687
|
+
this._sandboxId = void 0;
|
|
688
|
+
}
|
|
689
|
+
if (!this._environmentId) throw new Error("environmentId is required");
|
|
690
|
+
const body = JSON.stringify({
|
|
691
|
+
id: this.id,
|
|
692
|
+
environmentId: this._environmentId,
|
|
693
|
+
idleTimeoutMinutes: this._idleTimeoutMinutes,
|
|
694
|
+
networkIsolation: this._networkIsolation,
|
|
695
|
+
env: this._env
|
|
696
|
+
});
|
|
697
|
+
let response;
|
|
698
|
+
for (let attempt = 1;; attempt++) try {
|
|
699
|
+
response = await this._client.request("/sandbox", {
|
|
700
|
+
method: "POST",
|
|
701
|
+
headers: { "content-type": "application/json" },
|
|
702
|
+
body
|
|
703
|
+
});
|
|
704
|
+
break;
|
|
705
|
+
} catch (error) {
|
|
706
|
+
if (!(error instanceof PlatformApiError && error.status >= 500) || attempt >= CREATE_MAX_ATTEMPTS) throw error;
|
|
707
|
+
await new Promise((resolve) => setTimeout(resolve, CREATE_RETRY_BASE_DELAY_MS * attempt));
|
|
708
|
+
}
|
|
709
|
+
const json = await response.json();
|
|
710
|
+
this._sandboxId = json.id;
|
|
711
|
+
this._createdAt = json.createdAt ? new Date(json.createdAt) : /* @__PURE__ */ new Date();
|
|
712
|
+
}
|
|
713
|
+
async stop() {
|
|
714
|
+
await this.destroy();
|
|
715
|
+
}
|
|
716
|
+
async destroy() {
|
|
717
|
+
if (!this._sandboxId) return;
|
|
718
|
+
await this._client.request(`/sandbox/${encodeURIComponent(this._sandboxId)}`, { method: "DELETE" });
|
|
719
|
+
this._sandboxId = void 0;
|
|
720
|
+
this._createdAt = null;
|
|
721
|
+
this._lease = null;
|
|
722
|
+
}
|
|
723
|
+
/**
|
|
724
|
+
* Execute a command on the remote sandbox.
|
|
725
|
+
*
|
|
726
|
+
* `command` is a **shell string**: it is concatenated verbatim into the
|
|
727
|
+
* command line sent to the remote shell, which lets callers use pipes,
|
|
728
|
+
* redirects, and chaining (`ls -la | grep foo`). This matches the contract
|
|
729
|
+
* of {@link MastraSandbox} and the local sandbox implementation.
|
|
730
|
+
*
|
|
731
|
+
* `args`, when provided, are always shell-quoted so they cannot inject
|
|
732
|
+
* additional shell syntax.
|
|
733
|
+
*
|
|
734
|
+
* Security: callers MUST NOT pass untrusted input as `command`. If any part
|
|
735
|
+
* of the invocation is derived from an untrusted source, pass it through
|
|
736
|
+
* `args` (which is safely quoted) or shell-quote it yourself before
|
|
737
|
+
* inclusion. Untrusted `command` values allow arbitrary shell syntax
|
|
738
|
+
* execution on the remote sandbox.
|
|
739
|
+
*/
|
|
740
|
+
async executeCommand(command, args, options) {
|
|
741
|
+
await this.ensureRunning();
|
|
742
|
+
if (!this._sandboxId) throw new _mastra_core_workspace.SandboxNotReadyError(this.id);
|
|
743
|
+
const started = Date.now();
|
|
744
|
+
const fullCommand = buildCommand(command, args);
|
|
745
|
+
const effectiveTimeout = options?.timeout ?? this._timeout;
|
|
746
|
+
if (this._directExecAvailable !== false) {
|
|
747
|
+
const leaseResult = await this._tryDirectExec(fullCommand, effectiveTimeout, options);
|
|
748
|
+
if (leaseResult) return {
|
|
749
|
+
...leaseResult,
|
|
750
|
+
executionTimeMs: Date.now() - started
|
|
751
|
+
};
|
|
752
|
+
}
|
|
753
|
+
return this._execViaProxy(fullCommand, effectiveTimeout, options, started);
|
|
754
|
+
}
|
|
755
|
+
async _tryDirectExec(fullCommand, effectiveTimeout, options) {
|
|
756
|
+
let lease;
|
|
757
|
+
try {
|
|
758
|
+
lease = await this._ensureLease();
|
|
759
|
+
} catch (error) {
|
|
760
|
+
if (error instanceof PlatformApiError && (error.status === 404 || error.status === 501)) {
|
|
761
|
+
this._directExecAvailable = false;
|
|
762
|
+
return null;
|
|
763
|
+
}
|
|
764
|
+
throw error;
|
|
765
|
+
}
|
|
766
|
+
this._directExecAvailable = true;
|
|
767
|
+
const filteredEnv = options?.env ? Object.fromEntries(Object.entries(options.env).filter((entry) => entry[1] !== void 0)) : void 0;
|
|
768
|
+
const result = await execViaLease(lease, {
|
|
769
|
+
command: fullCommand,
|
|
770
|
+
...options?.cwd !== void 0 && { cwd: options.cwd },
|
|
771
|
+
...filteredEnv !== void 0 && { env: filteredEnv },
|
|
772
|
+
...effectiveTimeout != null && effectiveTimeout > 0 && { timeoutMs: effectiveTimeout },
|
|
773
|
+
...this._webSocketFactory && { webSocketFactory: this._webSocketFactory }
|
|
774
|
+
});
|
|
775
|
+
if (result.exitCode === null && !result.timedOut) {
|
|
776
|
+
this._lease = null;
|
|
777
|
+
return null;
|
|
778
|
+
}
|
|
779
|
+
const exitCode = result.exitCode ?? 124;
|
|
780
|
+
return {
|
|
781
|
+
success: exitCode === 0,
|
|
782
|
+
exitCode,
|
|
783
|
+
stdout: result.stdout,
|
|
784
|
+
stderr: result.stderr,
|
|
785
|
+
timedOut: result.timedOut,
|
|
786
|
+
command: fullCommand
|
|
787
|
+
};
|
|
788
|
+
}
|
|
789
|
+
async _execViaProxy(fullCommand, effectiveTimeout, options, started) {
|
|
790
|
+
if (!this._sandboxId) throw new _mastra_core_workspace.SandboxNotReadyError(this.id);
|
|
791
|
+
const timeoutSec = effectiveTimeout != null ? Math.ceil(effectiveTimeout / 1e3) : void 0;
|
|
792
|
+
const clientSignal = effectiveTimeout != null && effectiveTimeout > 0 ? AbortSignal.timeout(effectiveTimeout + 3e4) : void 0;
|
|
793
|
+
const json = await (await this._client.request(`/sandbox/${encodeURIComponent(this._sandboxId)}/exec`, {
|
|
794
|
+
method: "POST",
|
|
795
|
+
headers: { "content-type": "application/json" },
|
|
796
|
+
body: JSON.stringify({
|
|
797
|
+
command: fullCommand,
|
|
798
|
+
timeoutSec,
|
|
799
|
+
cwd: options?.cwd,
|
|
800
|
+
env: options?.env
|
|
801
|
+
}),
|
|
802
|
+
signal: clientSignal
|
|
803
|
+
})).json();
|
|
804
|
+
const exitCode = json.exitCode ?? (json.timedOut ? 124 : 1);
|
|
805
|
+
return {
|
|
806
|
+
success: exitCode === 0,
|
|
807
|
+
exitCode,
|
|
808
|
+
stdout: json.stdout,
|
|
809
|
+
stderr: json.stderr,
|
|
810
|
+
executionTimeMs: Date.now() - started,
|
|
811
|
+
timedOut: json.timedOut,
|
|
812
|
+
command: fullCommand
|
|
813
|
+
};
|
|
814
|
+
}
|
|
815
|
+
/**
|
|
816
|
+
* Return a cached exec lease, minting a fresh one when the cache is empty
|
|
817
|
+
* or the JWT is within {@link LEASE_REFRESH_MARGIN_MS} of `expiresAt`.
|
|
818
|
+
*
|
|
819
|
+
* Callers are expected to be on the "sandbox is running" path; we don't
|
|
820
|
+
* re-check `_sandboxId` here because `executeCommand` already gated on it.
|
|
821
|
+
*/
|
|
822
|
+
async _ensureLease() {
|
|
823
|
+
const now = Date.now();
|
|
824
|
+
if (this._lease && this._lease.expiresAtMs !== null && this._lease.expiresAtMs - LEASE_REFRESH_MARGIN_MS > now) return this._lease;
|
|
825
|
+
if (this._leaseInFlight) return this._leaseInFlight;
|
|
826
|
+
if (!this._sandboxId) throw new _mastra_core_workspace.SandboxNotReadyError(this.id);
|
|
827
|
+
const sandboxId = this._sandboxId;
|
|
828
|
+
const inFlight = (async () => {
|
|
829
|
+
const json = await (await this._client.request(`/sandbox/${encodeURIComponent(sandboxId)}/exec-lease`, { method: "POST" })).json();
|
|
830
|
+
const expiresAtMs = json.expiresAt ? Date.parse(json.expiresAt) : null;
|
|
831
|
+
const lease = {
|
|
832
|
+
jwt: json.jwt,
|
|
833
|
+
wsEndpoint: json.wsEndpoint,
|
|
834
|
+
subprotocol: json.subprotocol,
|
|
835
|
+
expiresAt: json.expiresAt,
|
|
836
|
+
expiresAtMs: expiresAtMs !== null && !Number.isNaN(expiresAtMs) ? expiresAtMs : null
|
|
837
|
+
};
|
|
838
|
+
this._lease = lease;
|
|
839
|
+
return lease;
|
|
840
|
+
})();
|
|
841
|
+
this._leaseInFlight = inFlight;
|
|
842
|
+
try {
|
|
843
|
+
return await inFlight;
|
|
844
|
+
} finally {
|
|
845
|
+
if (this._leaseInFlight === inFlight) this._leaseInFlight = null;
|
|
846
|
+
}
|
|
847
|
+
}
|
|
848
|
+
async getInfo() {
|
|
849
|
+
if (!this._sandboxId) return {
|
|
850
|
+
id: this.id,
|
|
851
|
+
name: this.name,
|
|
852
|
+
provider: this.provider,
|
|
853
|
+
status: this.status,
|
|
854
|
+
createdAt: this._createdAt ?? /* @__PURE__ */ new Date()
|
|
855
|
+
};
|
|
856
|
+
const json = await (await this._client.request(`/sandbox/${encodeURIComponent(this._sandboxId)}`)).json();
|
|
857
|
+
return {
|
|
858
|
+
id: json.id,
|
|
859
|
+
name: this.name,
|
|
860
|
+
provider: this.provider,
|
|
861
|
+
status: this.status,
|
|
862
|
+
createdAt: json.createdAt ? new Date(json.createdAt) : this._createdAt ?? /* @__PURE__ */ new Date(),
|
|
863
|
+
metadata: {
|
|
864
|
+
sandboxId: json.id,
|
|
865
|
+
providerResourceId: json.providerResourceId ?? void 0,
|
|
866
|
+
platformStatus: json.status
|
|
867
|
+
}
|
|
868
|
+
};
|
|
869
|
+
}
|
|
870
|
+
getInstructions(opts) {
|
|
871
|
+
const defaultInstructions = `Platform sandbox${this._sandboxId ? ` ${this._sandboxId}` : ""}. Execute commands with the sandbox command APIs.`;
|
|
872
|
+
if (typeof this._instructionsOverride === "function") return this._instructionsOverride({
|
|
873
|
+
defaultInstructions,
|
|
874
|
+
requestContext: opts?.requestContext
|
|
875
|
+
});
|
|
876
|
+
if (typeof this._instructionsOverride === "string") return this._instructionsOverride;
|
|
877
|
+
return defaultInstructions;
|
|
878
|
+
}
|
|
584
879
|
};
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
880
|
+
//#endregion
|
|
881
|
+
//#region src/provider.ts
|
|
882
|
+
const platformSandboxProvider = {
|
|
883
|
+
id: "platform",
|
|
884
|
+
name: "Mastra Platform Sandbox",
|
|
885
|
+
description: "Environment-scoped sandbox execution through Mastra Platform workspace proxy",
|
|
886
|
+
configSchema: {
|
|
887
|
+
type: "object",
|
|
888
|
+
properties: {
|
|
889
|
+
accessToken: {
|
|
890
|
+
type: "string",
|
|
891
|
+
description: "Mastra Platform secret key (falls back to MASTRA_PLATFORM_SECRET_KEY)"
|
|
892
|
+
},
|
|
893
|
+
projectId: {
|
|
894
|
+
type: "string",
|
|
895
|
+
description: "Platform project ID (falls back to MASTRA_PROJECT_ID)"
|
|
896
|
+
},
|
|
897
|
+
environmentId: {
|
|
898
|
+
type: "string",
|
|
899
|
+
description: "Platform environment ID (falls back to MASTRA_ENVIRONMENT_ID)"
|
|
900
|
+
},
|
|
901
|
+
sandboxId: {
|
|
902
|
+
type: "string",
|
|
903
|
+
description: "Reattach to an existing Platform sandbox by ID"
|
|
904
|
+
},
|
|
905
|
+
idleTimeoutMinutes: {
|
|
906
|
+
type: "number",
|
|
907
|
+
description: "Minutes before the sandbox can be destroyed while idle"
|
|
908
|
+
},
|
|
909
|
+
networkIsolation: {
|
|
910
|
+
type: "string",
|
|
911
|
+
description: "Network isolation mode",
|
|
912
|
+
enum: ["ISOLATED", "PRIVATE"],
|
|
913
|
+
default: "ISOLATED"
|
|
914
|
+
},
|
|
915
|
+
env: {
|
|
916
|
+
type: "object",
|
|
917
|
+
description: "Environment variables",
|
|
918
|
+
additionalProperties: { type: "string" }
|
|
919
|
+
},
|
|
920
|
+
timeout: {
|
|
921
|
+
type: "number",
|
|
922
|
+
description: "Default command timeout in ms"
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
},
|
|
926
|
+
createSandbox: (config) => new PlatformSandbox(config)
|
|
613
927
|
};
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
928
|
+
const platformFilesystemProvider = {
|
|
929
|
+
id: "platform",
|
|
930
|
+
name: "Mastra Platform Filesystem",
|
|
931
|
+
description: "Bucket-backed filesystem access through Mastra Platform workspace proxy",
|
|
932
|
+
configSchema: {
|
|
933
|
+
type: "object",
|
|
934
|
+
properties: {
|
|
935
|
+
accessToken: {
|
|
936
|
+
type: "string",
|
|
937
|
+
description: "Mastra Platform secret key (falls back to MASTRA_PLATFORM_SECRET_KEY)"
|
|
938
|
+
},
|
|
939
|
+
projectId: {
|
|
940
|
+
type: "string",
|
|
941
|
+
description: "Platform project ID (falls back to MASTRA_PROJECT_ID)"
|
|
942
|
+
},
|
|
943
|
+
bucketName: {
|
|
944
|
+
type: "string",
|
|
945
|
+
description: "Platform workspace bucket name (falls back to MASTRA_PLATFORM_BUCKET_NAME)"
|
|
946
|
+
},
|
|
947
|
+
readOnly: {
|
|
948
|
+
type: "boolean",
|
|
949
|
+
description: "Mount as read-only",
|
|
950
|
+
default: false
|
|
951
|
+
}
|
|
952
|
+
}
|
|
953
|
+
},
|
|
954
|
+
createFilesystem: (config) => new PlatformFilesystem(config)
|
|
634
955
|
};
|
|
635
|
-
|
|
956
|
+
//#endregion
|
|
636
957
|
exports.PlatformApiError = PlatformApiError;
|
|
637
958
|
exports.PlatformClient = PlatformClient;
|
|
638
959
|
exports.PlatformFilesystem = PlatformFilesystem;
|
|
639
960
|
exports.PlatformSandbox = PlatformSandbox;
|
|
640
961
|
exports.platformFilesystemProvider = platformFilesystemProvider;
|
|
641
962
|
exports.platformSandboxProvider = platformSandboxProvider;
|
|
642
|
-
|
|
963
|
+
|
|
643
964
|
//# sourceMappingURL=index.cjs.map
|