@mastra/s3 0.6.0 → 0.6.1-alpha.1

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.
Files changed (8) hide show
  1. package/CHANGELOG.md +25 -0
  2. package/dist/filesystem/index.d.ts +1 -1
  3. package/dist/filesystem/index.d.ts.map +1 -1
  4. package/dist/index.cjs +895 -831
  5. package/dist/index.cjs.map +1 -1
  6. package/dist/index.js +892 -827
  7. package/dist/index.js.map +1 -1
  8. package/package.json +15 -14
package/dist/index.cjs CHANGED
@@ -1,849 +1,913 @@
1
- 'use strict';
2
-
3
- var clientS3 = require('@aws-sdk/client-s3');
4
- var workspace = require('@mastra/core/workspace');
5
- var storage = require('@mastra/core/storage');
6
-
7
- // src/filesystem/index.ts
8
- var MIME_TYPES = {
9
- // Text
10
- ".txt": "text/plain",
11
- ".md": "text/markdown",
12
- ".markdown": "text/markdown",
13
- ".html": "text/html",
14
- ".htm": "text/html",
15
- ".css": "text/css",
16
- ".csv": "text/csv",
17
- ".xml": "text/xml",
18
- // Code
19
- ".js": "text/javascript",
20
- ".mjs": "text/javascript",
21
- ".ts": "text/typescript",
22
- ".tsx": "text/typescript",
23
- ".jsx": "text/javascript",
24
- ".json": "application/json",
25
- ".yaml": "text/yaml",
26
- ".yml": "text/yaml",
27
- ".py": "text/x-python",
28
- ".rb": "text/x-ruby",
29
- ".sh": "text/x-shellscript",
30
- ".bash": "text/x-shellscript",
31
- // Images
32
- ".png": "image/png",
33
- ".jpg": "image/jpeg",
34
- ".jpeg": "image/jpeg",
35
- ".gif": "image/gif",
36
- ".svg": "image/svg+xml",
37
- ".webp": "image/webp",
38
- ".ico": "image/x-icon",
39
- // Documents
40
- ".pdf": "application/pdf",
41
- // Archives
42
- ".zip": "application/zip",
43
- ".gz": "application/gzip",
44
- ".tar": "application/x-tar"
1
+ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
2
+ let _aws_sdk_client_s3 = require("@aws-sdk/client-s3");
3
+ let _mastra_core_workspace = require("@mastra/core/workspace");
4
+ let _mastra_core_storage = require("@mastra/core/storage");
5
+ //#region src/filesystem/index.ts
6
+ /**
7
+ * Common MIME types by file extension.
8
+ */
9
+ const MIME_TYPES = {
10
+ ".txt": "text/plain",
11
+ ".md": "text/markdown",
12
+ ".markdown": "text/markdown",
13
+ ".html": "text/html",
14
+ ".htm": "text/html",
15
+ ".css": "text/css",
16
+ ".csv": "text/csv",
17
+ ".xml": "text/xml",
18
+ ".js": "text/javascript",
19
+ ".mjs": "text/javascript",
20
+ ".ts": "text/typescript",
21
+ ".tsx": "text/typescript",
22
+ ".jsx": "text/javascript",
23
+ ".json": "application/json",
24
+ ".yaml": "text/yaml",
25
+ ".yml": "text/yaml",
26
+ ".py": "text/x-python",
27
+ ".rb": "text/x-ruby",
28
+ ".sh": "text/x-shellscript",
29
+ ".bash": "text/x-shellscript",
30
+ ".png": "image/png",
31
+ ".jpg": "image/jpeg",
32
+ ".jpeg": "image/jpeg",
33
+ ".gif": "image/gif",
34
+ ".svg": "image/svg+xml",
35
+ ".webp": "image/webp",
36
+ ".ico": "image/x-icon",
37
+ ".pdf": "application/pdf",
38
+ ".zip": "application/zip",
39
+ ".gz": "application/gzip",
40
+ ".tar": "application/x-tar"
45
41
  };
42
+ /**
43
+ * Get MIME type from file path extension.
44
+ */
46
45
  function getMimeType(path) {
47
- const ext = path.toLowerCase().match(/\.[^.]+$/)?.[0];
48
- return ext ? MIME_TYPES[ext] ?? "application/octet-stream" : "application/octet-stream";
46
+ const ext = path.toLowerCase().match(/\.[^.]+$/)?.[0];
47
+ return ext ? MIME_TYPES[ext] ?? "application/octet-stream" : "application/octet-stream";
49
48
  }
50
- function isNotFoundError(error) {
51
- if (!error || typeof error !== "object" || !("name" in error)) return false;
52
- const name = error.name;
53
- return name === "NotFound" || name === "NoSuchKey" || name === "404";
49
+ /** Check if an error is a "not found" error from the S3 SDK. */
50
+ function isNotFoundError$1(error) {
51
+ if (!error || typeof error !== "object" || !("name" in error)) return false;
52
+ const name = error.name;
53
+ return name === "NotFound" || name === "NoSuchKey" || name === "404";
54
54
  }
55
+ /** Check if an error is an access denied error from the S3 SDK. */
55
56
  function isAccessDeniedError(error) {
56
- if (!error || typeof error !== "object") return false;
57
- const err = error;
58
- return err.name === "AccessDenied" || err.$metadata?.httpStatusCode === 403;
57
+ if (!error || typeof error !== "object") return false;
58
+ const err = error;
59
+ return err.name === "AccessDenied" || err.$metadata?.httpStatusCode === 403;
59
60
  }
60
- function trimSlashes(s) {
61
- let start = 0;
62
- let end = s.length;
63
- while (start < end && s[start] === "/") start++;
64
- while (end > start && s[end - 1] === "/") end--;
65
- return s.slice(start, end);
61
+ /**
62
+ * S3 filesystem implementation.
63
+ *
64
+ * Stores files in an S3 bucket or S3-compatible storage service.
65
+ * Supports mounting into E2B sandboxes via s3fs-fuse.
66
+ *
67
+ * @example AWS S3
68
+ * ```typescript
69
+ * import { S3Filesystem } from '@mastra/s3';
70
+ *
71
+ * const fs = new S3Filesystem({
72
+ * bucket: 'my-bucket',
73
+ * region: 'us-east-1',
74
+ * accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
75
+ * secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
76
+ * });
77
+ * ```
78
+ *
79
+ * @example Cloudflare R2
80
+ * ```typescript
81
+ * import { S3Filesystem } from '@mastra/s3';
82
+ *
83
+ * const fs = new S3Filesystem({
84
+ * bucket: 'my-bucket',
85
+ * region: 'auto',
86
+ * accessKeyId: process.env.R2_ACCESS_KEY_ID!,
87
+ * secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,
88
+ * endpoint: `https://${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,
89
+ * });
90
+ * ```
91
+ *
92
+ * @example MinIO (local)
93
+ * ```typescript
94
+ * import { S3Filesystem } from '@mastra/s3';
95
+ *
96
+ * const fs = new S3Filesystem({
97
+ * bucket: 'my-bucket',
98
+ * region: 'us-east-1',
99
+ * accessKeyId: 'minioadmin',
100
+ * secretAccessKey: 'minioadmin',
101
+ * endpoint: 'http://localhost:9000',
102
+ * forcePathStyle: true,
103
+ * });
104
+ * ```
105
+ */
106
+ /** Trim leading and trailing slashes without regex (avoids polynomial regex on user input). */
107
+ function trimSlashes$1(s) {
108
+ let start = 0;
109
+ let end = s.length;
110
+ while (start < end && s[start] === "/") start++;
111
+ while (end > start && s[end - 1] === "/") end--;
112
+ return s.slice(start, end);
66
113
  }
67
- var S3Filesystem = class extends workspace.MastraFilesystem {
68
- id;
69
- name = "S3Filesystem";
70
- provider = "s3";
71
- readOnly;
72
- status = "pending";
73
- // Display metadata for UI
74
- displayName;
75
- icon = "s3";
76
- description;
77
- bucket;
78
- region;
79
- credentials;
80
- accessKeyId;
81
- secretAccessKey;
82
- sessionToken;
83
- endpoint;
84
- forcePathStyle;
85
- prefix;
86
- _client = null;
87
- constructor(options) {
88
- super({ ...options, name: "S3Filesystem" });
89
- this.id = options.id ?? `s3-fs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
90
- this.bucket = options.bucket;
91
- this.region = options.region;
92
- this.credentials = options.credentials;
93
- this.accessKeyId = options.accessKeyId;
94
- this.secretAccessKey = options.secretAccessKey;
95
- this.sessionToken = options.sessionToken;
96
- this.endpoint = options.endpoint;
97
- this.forcePathStyle = options.forcePathStyle ?? !!options.endpoint;
98
- const trimmedPrefix = options.prefix ? trimSlashes(options.prefix) : "";
99
- this.prefix = trimmedPrefix ? trimmedPrefix + "/" : "";
100
- this.icon = options.icon ?? this.detectIconFromEndpoint(options.endpoint);
101
- this.displayName = options.displayName ?? this.getDefaultDisplayName(this.icon);
102
- this.description = options.description;
103
- this.readOnly = options.readOnly;
104
- }
105
- /**
106
- * Get the underlying S3Client instance for direct access to AWS S3 APIs.
107
- *
108
- * Use this when you need to access S3 features not exposed through the
109
- * WorkspaceFilesystem interface (e.g., presigned URLs, multipart uploads,
110
- * custom S3 operations, etc.).
111
- *
112
- * @example Generate a presigned URL
113
- * ```typescript
114
- * import { GetObjectCommand } from '@aws-sdk/client-s3';
115
- * import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
116
- *
117
- * const s3Client = fs.client;
118
- * const url = await getSignedUrl(s3Client, new GetObjectCommand({
119
- * Bucket: 'my-bucket',
120
- * Key: 'my-file.txt',
121
- * }));
122
- * ```
123
- */
124
- get client() {
125
- return this.getClient();
126
- }
127
- /**
128
- * Get mount configuration for E2B sandbox.
129
- * Returns S3-compatible config that works with s3fs-fuse.
130
- *
131
- * Only static `accessKeyId`/`secretAccessKey`/`sessionToken` are included in the
132
- * returned config. If credentials are provided only via the `credentials` option
133
- * (provider function), the returned config will have no credentials because FUSE
134
- * mounts cannot call a provider function. Use static credentials for sandbox
135
- * mount compatibility.
136
- */
137
- getMountConfig() {
138
- const config = {
139
- type: "s3",
140
- bucket: this.bucket,
141
- region: this.region,
142
- endpoint: this.endpoint
143
- };
144
- if (this.accessKeyId && this.secretAccessKey) {
145
- config.accessKeyId = this.accessKeyId;
146
- config.secretAccessKey = this.secretAccessKey;
147
- if (this.sessionToken) {
148
- config.sessionToken = this.sessionToken;
149
- }
150
- }
151
- if (this.prefix) {
152
- config.prefix = this.prefix;
153
- }
154
- if (this.readOnly) {
155
- config.readOnly = true;
156
- }
157
- return config;
158
- }
159
- /**
160
- * Get filesystem info for status reporting.
161
- */
162
- getInfo() {
163
- return {
164
- id: this.id,
165
- name: this.name,
166
- provider: this.provider,
167
- status: this.status,
168
- error: this.error,
169
- readOnly: this.readOnly,
170
- icon: this.icon,
171
- metadata: {
172
- bucket: this.bucket,
173
- region: this.region,
174
- ...this.endpoint && { endpoint: this.endpoint },
175
- ...this.prefix && { prefix: this.prefix }
176
- }
177
- };
178
- }
179
- /**
180
- * Handle an error, checking for access denied and updating status accordingly.
181
- * Returns the error for re-throwing.
182
- */
183
- handleError(error) {
184
- if (isAccessDeniedError(error)) {
185
- this.status = "error";
186
- this.error = "Access denied - check credentials and bucket permissions";
187
- }
188
- return error;
189
- }
190
- /**
191
- * Get instructions describing this S3 filesystem.
192
- * Used by agents to understand storage semantics.
193
- */
194
- getInstructions() {
195
- const providerName = this.displayName || "S3";
196
- const access = this.readOnly ? "Read-only" : "Persistent";
197
- return `${providerName} storage in bucket "${this.bucket}". ${access} storage - files are retained across sessions.`;
198
- }
199
- /**
200
- * Detect the appropriate icon based on the S3 endpoint.
201
- */
202
- detectIconFromEndpoint(endpoint) {
203
- if (!endpoint) {
204
- return "aws-s3";
205
- }
206
- let hostname;
207
- try {
208
- const url = new URL(endpoint);
209
- hostname = url.hostname.toLowerCase();
210
- } catch {
211
- hostname = endpoint.toLowerCase();
212
- }
213
- if (hostname === "r2.cloudflarestorage.com" || hostname.endsWith(".r2.cloudflarestorage.com") || hostname.endsWith(".cloudflare.com")) {
214
- return "r2";
215
- }
216
- if (hostname === "storage.googleapis.com" || hostname.endsWith(".storage.googleapis.com") || hostname.endsWith(".googleapis.com")) {
217
- return "gcs";
218
- }
219
- if (hostname === "blob.core.windows.net" || hostname.endsWith(".blob.core.windows.net") || hostname.endsWith(".azure.com")) {
220
- return "azure";
221
- }
222
- if (hostname.includes("minio")) {
223
- return "minio";
224
- }
225
- return "s3";
226
- }
227
- /**
228
- * Get a user-friendly display name based on the icon/provider.
229
- */
230
- getDefaultDisplayName(icon) {
231
- switch (icon) {
232
- case "aws-s3":
233
- return "AWS S3";
234
- case "r2":
235
- case "cloudflare":
236
- case "cloudflare-r2":
237
- return "Cloudflare R2";
238
- case "gcs":
239
- case "google-cloud":
240
- case "google-cloud-storage":
241
- return "Google Cloud Storage";
242
- case "azure":
243
- case "azure-blob":
244
- return "Azure Blob";
245
- case "minio":
246
- return "MinIO";
247
- case "s3":
248
- return "S3";
249
- default:
250
- return void 0;
251
- }
252
- }
253
- getClient() {
254
- if (this._client) return this._client;
255
- const hasStaticCredentials = this.accessKeyId && this.secretAccessKey;
256
- let credentials;
257
- if (this.credentials) {
258
- credentials = this.credentials;
259
- } else if (hasStaticCredentials) {
260
- credentials = {
261
- accessKeyId: this.accessKeyId,
262
- secretAccessKey: this.secretAccessKey,
263
- ...this.sessionToken && { sessionToken: this.sessionToken }
264
- };
265
- }
266
- this._client = new clientS3.S3Client({
267
- region: this.region,
268
- ...credentials !== void 0 && { credentials },
269
- endpoint: this.endpoint,
270
- forcePathStyle: this.forcePathStyle
271
- });
272
- return this._client;
273
- }
274
- /**
275
- * Ensure the filesystem is initialized and return the S3 client.
276
- * Uses base class ensureReady() for status management, then returns client.
277
- */
278
- async getReadyClient() {
279
- await this.ensureReady();
280
- return this.getClient();
281
- }
282
- toKey(path) {
283
- const cleanPath = path.replace(/^\/+/, "").replace(/^\.(?:\/|$)/, "");
284
- return this.prefix + cleanPath;
285
- }
286
- // ---------------------------------------------------------------------------
287
- // File Operations
288
- // ---------------------------------------------------------------------------
289
- async readFile(path, options) {
290
- const client = await this.getReadyClient();
291
- try {
292
- const response = await client.send(
293
- new clientS3.GetObjectCommand({
294
- Bucket: this.bucket,
295
- Key: this.toKey(path)
296
- })
297
- );
298
- const body = await response.Body?.transformToByteArray();
299
- if (!body) throw new workspace.FileNotFoundError(path);
300
- const buffer = Buffer.from(body);
301
- if (options?.encoding) {
302
- return buffer.toString(options.encoding);
303
- }
304
- return buffer;
305
- } catch (error) {
306
- if (isNotFoundError(error)) {
307
- throw new workspace.FileNotFoundError(path);
308
- }
309
- throw this.handleError(error);
310
- }
311
- }
312
- async writeFile(path, content, options) {
313
- const client = await this.getReadyClient();
314
- if (options?.overwrite === false && await this.exists(path)) {
315
- throw new workspace.FileExistsError(path);
316
- }
317
- const body = typeof content === "string" ? Buffer.from(content, "utf-8") : Buffer.from(content);
318
- const contentType = getMimeType(path);
319
- await client.send(
320
- new clientS3.PutObjectCommand({
321
- Bucket: this.bucket,
322
- Key: this.toKey(path),
323
- Body: body,
324
- ContentType: contentType
325
- })
326
- );
327
- }
328
- async appendFile(path, content) {
329
- let existing = "";
330
- try {
331
- existing = await this.readFile(path, { encoding: "utf-8" });
332
- } catch (error) {
333
- if (error instanceof workspace.FileNotFoundError) ; else {
334
- throw error;
335
- }
336
- }
337
- const appendContent = typeof content === "string" ? content : Buffer.from(content).toString("utf-8");
338
- await this.writeFile(path, existing + appendContent);
339
- }
340
- async deleteFile(path, options) {
341
- const isDir = await this.isDirectory(path);
342
- if (isDir) {
343
- await this.rmdir(path, { recursive: true, force: options?.force });
344
- return;
345
- }
346
- const client = await this.getReadyClient();
347
- try {
348
- await client.send(
349
- new clientS3.DeleteObjectCommand({
350
- Bucket: this.bucket,
351
- Key: this.toKey(path)
352
- })
353
- );
354
- } catch (error) {
355
- if (options?.force) return;
356
- if (isNotFoundError(error)) {
357
- throw new workspace.FileNotFoundError(path);
358
- }
359
- throw this.handleError(error);
360
- }
361
- }
362
- async copyFile(src, dest, options) {
363
- const client = await this.getReadyClient();
364
- if (options?.overwrite === false && await this.exists(dest)) {
365
- throw new workspace.FileExistsError(dest);
366
- }
367
- try {
368
- await client.send(
369
- new clientS3.CopyObjectCommand({
370
- Bucket: this.bucket,
371
- CopySource: `${this.bucket}/${encodeURIComponent(this.toKey(src)).replace(/%2F/g, "/")}`,
372
- Key: this.toKey(dest)
373
- })
374
- );
375
- } catch (error) {
376
- if (isNotFoundError(error)) {
377
- throw new workspace.FileNotFoundError(src);
378
- }
379
- throw this.handleError(error);
380
- }
381
- }
382
- async moveFile(src, dest, options) {
383
- await this.copyFile(src, dest, options);
384
- await this.deleteFile(src, { force: true });
385
- }
386
- // ---------------------------------------------------------------------------
387
- // Directory Operations
388
- // ---------------------------------------------------------------------------
389
- async mkdir(_path, _options) {
390
- }
391
- async rmdir(path, options) {
392
- if (!options?.recursive) {
393
- const entries = await this.readdir(path);
394
- if (entries.length > 0) {
395
- throw new Error(`Directory not empty: ${path}`);
396
- }
397
- return;
398
- }
399
- const client = await this.getReadyClient();
400
- const prefix = this.toKey(path).replace(/\/$/, "") + "/";
401
- let continuationToken;
402
- do {
403
- const listResponse = await client.send(
404
- new clientS3.ListObjectsV2Command({
405
- Bucket: this.bucket,
406
- Prefix: prefix,
407
- ContinuationToken: continuationToken
408
- })
409
- );
410
- if (listResponse.Contents && listResponse.Contents.length > 0) {
411
- const deleteResponse = await client.send(
412
- new clientS3.DeleteObjectsCommand({
413
- Bucket: this.bucket,
414
- Delete: {
415
- Objects: listResponse.Contents.filter((obj) => !!obj.Key).map((obj) => ({
416
- Key: obj.Key
417
- }))
418
- }
419
- })
420
- );
421
- if (deleteResponse.Errors && deleteResponse.Errors.length > 0) {
422
- throw new Error(`Failed to delete ${deleteResponse.Errors.length} object(s) in ${path}`);
423
- }
424
- }
425
- continuationToken = listResponse.NextContinuationToken;
426
- } while (continuationToken);
427
- }
428
- async readdir(path, options) {
429
- const client = await this.getReadyClient();
430
- const prefix = this.toKey(path).replace(/\/$/, "");
431
- const searchPrefix = prefix ? prefix + "/" : "";
432
- const entries = [];
433
- const seenDirs = /* @__PURE__ */ new Set();
434
- let continuationToken;
435
- do {
436
- const response = await client.send(
437
- new clientS3.ListObjectsV2Command({
438
- Bucket: this.bucket,
439
- Prefix: searchPrefix,
440
- Delimiter: options?.recursive ? void 0 : "/",
441
- ContinuationToken: continuationToken
442
- })
443
- );
444
- if (response.Contents) {
445
- for (const obj of response.Contents) {
446
- const key = obj.Key;
447
- if (!key || key === searchPrefix) continue;
448
- const relativePath = key.slice(searchPrefix.length);
449
- if (!relativePath) continue;
450
- if (relativePath.endsWith("/")) {
451
- const dirName = relativePath.slice(0, -1);
452
- if (!seenDirs.has(dirName)) {
453
- seenDirs.add(dirName);
454
- entries.push({ name: dirName, type: "directory" });
455
- }
456
- continue;
457
- }
458
- const name = options?.recursive ? relativePath : relativePath.split("/")[0];
459
- if (!name) continue;
460
- if (options?.extension) {
461
- const extensions = Array.isArray(options.extension) ? options.extension : [options.extension];
462
- if (!extensions.some((ext) => name.endsWith(ext))) {
463
- continue;
464
- }
465
- }
466
- entries.push({
467
- name,
468
- type: "file",
469
- size: obj.Size
470
- });
471
- }
472
- }
473
- if (response.CommonPrefixes) {
474
- for (const prefixObj of response.CommonPrefixes) {
475
- if (!prefixObj.Prefix) continue;
476
- const dirName = prefixObj.Prefix.slice(searchPrefix.length).replace(/\/$/, "");
477
- if (dirName && !seenDirs.has(dirName)) {
478
- seenDirs.add(dirName);
479
- entries.push({ name: dirName, type: "directory" });
480
- }
481
- }
482
- }
483
- continuationToken = response.NextContinuationToken;
484
- } while (continuationToken);
485
- return entries;
486
- }
487
- // ---------------------------------------------------------------------------
488
- // Path Operations
489
- // ---------------------------------------------------------------------------
490
- async exists(path) {
491
- const key = this.toKey(path);
492
- if (!key) return true;
493
- const client = await this.getReadyClient();
494
- try {
495
- await client.send(
496
- new clientS3.HeadObjectCommand({
497
- Bucket: this.bucket,
498
- Key: key
499
- })
500
- );
501
- return true;
502
- } catch (error) {
503
- if (!isNotFoundError(error)) throw this.handleError(error);
504
- }
505
- const response = await client.send(
506
- new clientS3.ListObjectsV2Command({
507
- Bucket: this.bucket,
508
- Prefix: key.replace(/\/$/, "") + "/",
509
- MaxKeys: 1
510
- })
511
- );
512
- return (response.Contents?.length ?? 0) > 0;
513
- }
514
- async stat(path) {
515
- const key = this.toKey(path);
516
- if (!key) {
517
- return {
518
- name: "",
519
- path,
520
- type: "directory",
521
- size: 0,
522
- createdAt: /* @__PURE__ */ new Date(),
523
- modifiedAt: /* @__PURE__ */ new Date()
524
- };
525
- }
526
- const client = await this.getReadyClient();
527
- try {
528
- const response = await client.send(
529
- new clientS3.HeadObjectCommand({
530
- Bucket: this.bucket,
531
- Key: key
532
- })
533
- );
534
- const name = path.split("/").pop() ?? "";
535
- return {
536
- name,
537
- path,
538
- type: "file",
539
- size: response.ContentLength ?? 0,
540
- createdAt: response.LastModified ?? /* @__PURE__ */ new Date(),
541
- modifiedAt: response.LastModified ?? /* @__PURE__ */ new Date()
542
- };
543
- } catch (error) {
544
- if (!isNotFoundError(error)) throw this.handleError(error);
545
- const isDir = await this.isDirectory(path);
546
- if (isDir) {
547
- const name = path.split("/").filter(Boolean).pop() ?? "";
548
- return {
549
- name,
550
- path,
551
- type: "directory",
552
- size: 0,
553
- createdAt: /* @__PURE__ */ new Date(),
554
- modifiedAt: /* @__PURE__ */ new Date()
555
- };
556
- }
557
- throw new workspace.FileNotFoundError(path);
558
- }
559
- }
560
- async isFile(path) {
561
- const key = this.toKey(path);
562
- if (!key) return false;
563
- const client = await this.getReadyClient();
564
- try {
565
- await client.send(
566
- new clientS3.HeadObjectCommand({
567
- Bucket: this.bucket,
568
- Key: key
569
- })
570
- );
571
- return true;
572
- } catch (error) {
573
- if (!isNotFoundError(error)) throw this.handleError(error);
574
- return false;
575
- }
576
- }
577
- async isDirectory(path) {
578
- const key = this.toKey(path);
579
- if (!key) return true;
580
- const client = await this.getReadyClient();
581
- const response = await client.send(
582
- new clientS3.ListObjectsV2Command({
583
- Bucket: this.bucket,
584
- Prefix: key.replace(/\/$/, "") + "/",
585
- MaxKeys: 1
586
- })
587
- );
588
- return (response.Contents?.length ?? 0) > 0;
589
- }
590
- // ---------------------------------------------------------------------------
591
- // Lifecycle (overrides base class protected methods)
592
- // ---------------------------------------------------------------------------
593
- /**
594
- * Initialize the S3 client.
595
- * Status management is handled by the base class.
596
- */
597
- async init() {
598
- const client = this.getClient();
599
- try {
600
- await client.send(new clientS3.HeadBucketCommand({ Bucket: this.bucket }));
601
- } catch (error) {
602
- const statusCode = error.$metadata?.httpStatusCode;
603
- const createError = (message2) => {
604
- const err = new Error(message2);
605
- if (statusCode) err.status = statusCode;
606
- return err;
607
- };
608
- if (isAccessDeniedError(error)) {
609
- throw createError(`Access denied to bucket "${this.bucket}" - check credentials and permissions`);
610
- }
611
- if (isNotFoundError(error)) {
612
- throw createError(`Bucket "${this.bucket}" not found`);
613
- }
614
- const message = error instanceof Error ? error.message : String(error);
615
- if (statusCode) {
616
- throw createError(`Failed to access bucket "${this.bucket}" (HTTP ${statusCode}): ${message}`);
617
- }
618
- throw error;
619
- }
620
- }
621
- /**
622
- * Clean up the S3 client.
623
- * Status management is handled by the base class.
624
- */
625
- async destroy() {
626
- this._client = null;
627
- }
114
+ var S3Filesystem = class extends _mastra_core_workspace.MastraFilesystem {
115
+ id;
116
+ name = "S3Filesystem";
117
+ provider = "s3";
118
+ readOnly;
119
+ status = "pending";
120
+ displayName;
121
+ icon = "s3";
122
+ description;
123
+ bucket;
124
+ region;
125
+ credentials;
126
+ accessKeyId;
127
+ secretAccessKey;
128
+ sessionToken;
129
+ endpoint;
130
+ forcePathStyle;
131
+ prefix;
132
+ _client = null;
133
+ constructor(options) {
134
+ super({
135
+ ...options,
136
+ name: "S3Filesystem"
137
+ });
138
+ this.id = options.id ?? `s3-fs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
139
+ this.bucket = options.bucket;
140
+ this.region = options.region;
141
+ this.credentials = options.credentials;
142
+ this.accessKeyId = options.accessKeyId;
143
+ this.secretAccessKey = options.secretAccessKey;
144
+ this.sessionToken = options.sessionToken;
145
+ this.endpoint = options.endpoint;
146
+ this.forcePathStyle = options.forcePathStyle ?? !!options.endpoint;
147
+ const trimmedPrefix = options.prefix ? trimSlashes$1(options.prefix) : "";
148
+ this.prefix = trimmedPrefix ? trimmedPrefix + "/" : "";
149
+ this.icon = options.icon ?? this.detectIconFromEndpoint(options.endpoint);
150
+ this.displayName = options.displayName ?? this.getDefaultDisplayName(this.icon);
151
+ this.description = options.description;
152
+ this.readOnly = options.readOnly;
153
+ }
154
+ /**
155
+ * Get the underlying S3Client instance for direct access to AWS S3 APIs.
156
+ *
157
+ * Use this when you need to access S3 features not exposed through the
158
+ * WorkspaceFilesystem interface (e.g., presigned URLs, multipart uploads,
159
+ * custom S3 operations, etc.).
160
+ *
161
+ * @example Generate a presigned URL
162
+ * ```typescript
163
+ * import { GetObjectCommand } from '@aws-sdk/client-s3';
164
+ * import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
165
+ *
166
+ * const s3Client = fs.client;
167
+ * const url = await getSignedUrl(s3Client, new GetObjectCommand({
168
+ * Bucket: 'my-bucket',
169
+ * Key: 'my-file.txt',
170
+ * }));
171
+ * ```
172
+ */
173
+ get client() {
174
+ return this.getClient();
175
+ }
176
+ /**
177
+ * Get mount configuration for E2B sandbox.
178
+ * Returns S3-compatible config that works with s3fs-fuse.
179
+ *
180
+ * Only static `accessKeyId`/`secretAccessKey`/`sessionToken` are included in the
181
+ * returned config. If credentials are provided only via the `credentials` option
182
+ * (provider function), the returned config will have no credentials because FUSE
183
+ * mounts cannot call a provider function. Use static credentials for sandbox
184
+ * mount compatibility.
185
+ */
186
+ getMountConfig() {
187
+ const config = {
188
+ type: "s3",
189
+ bucket: this.bucket,
190
+ region: this.region,
191
+ endpoint: this.endpoint
192
+ };
193
+ if (this.accessKeyId && this.secretAccessKey) {
194
+ config.accessKeyId = this.accessKeyId;
195
+ config.secretAccessKey = this.secretAccessKey;
196
+ if (this.sessionToken) config.sessionToken = this.sessionToken;
197
+ }
198
+ if (this.prefix) config.prefix = this.prefix;
199
+ if (this.readOnly) config.readOnly = true;
200
+ return config;
201
+ }
202
+ /**
203
+ * Get filesystem info for status reporting.
204
+ */
205
+ getInfo() {
206
+ return {
207
+ id: this.id,
208
+ name: this.name,
209
+ provider: this.provider,
210
+ status: this.status,
211
+ error: this.error,
212
+ readOnly: this.readOnly,
213
+ icon: this.icon,
214
+ metadata: {
215
+ bucket: this.bucket,
216
+ region: this.region,
217
+ ...this.endpoint && { endpoint: this.endpoint },
218
+ ...this.prefix && { prefix: this.prefix }
219
+ }
220
+ };
221
+ }
222
+ /**
223
+ * Handle an error, checking for access denied and updating status accordingly.
224
+ * Returns the error for re-throwing.
225
+ */
226
+ handleError(error) {
227
+ if (isAccessDeniedError(error)) {
228
+ this.status = "error";
229
+ this.error = "Access denied - check credentials and bucket permissions";
230
+ }
231
+ return error;
232
+ }
233
+ /**
234
+ * Get instructions describing this S3 filesystem.
235
+ * Used by agents to understand storage semantics.
236
+ */
237
+ getInstructions() {
238
+ const providerName = this.displayName || "S3";
239
+ const access = this.readOnly ? "Read-only" : "Persistent";
240
+ return `${providerName} storage in bucket "${this.bucket}". ${access} storage - files are retained across sessions.`;
241
+ }
242
+ /**
243
+ * Detect the appropriate icon based on the S3 endpoint.
244
+ */
245
+ detectIconFromEndpoint(endpoint) {
246
+ if (!endpoint) return "aws-s3";
247
+ let hostname;
248
+ try {
249
+ hostname = new URL(endpoint).hostname.toLowerCase();
250
+ } catch {
251
+ hostname = endpoint.toLowerCase();
252
+ }
253
+ if (hostname === "r2.cloudflarestorage.com" || hostname.endsWith(".r2.cloudflarestorage.com") || hostname.endsWith(".cloudflare.com")) return "r2";
254
+ if (hostname === "storage.googleapis.com" || hostname.endsWith(".storage.googleapis.com") || hostname.endsWith(".googleapis.com")) return "gcs";
255
+ if (hostname === "blob.core.windows.net" || hostname.endsWith(".blob.core.windows.net") || hostname.endsWith(".azure.com")) return "azure";
256
+ if (hostname.includes("minio")) return "minio";
257
+ return "s3";
258
+ }
259
+ /**
260
+ * Get a user-friendly display name based on the icon/provider.
261
+ */
262
+ getDefaultDisplayName(icon) {
263
+ switch (icon) {
264
+ case "aws-s3": return "AWS S3";
265
+ case "r2":
266
+ case "cloudflare":
267
+ case "cloudflare-r2": return "Cloudflare R2";
268
+ case "gcs":
269
+ case "google-cloud":
270
+ case "google-cloud-storage": return "Google Cloud Storage";
271
+ case "azure":
272
+ case "azure-blob": return "Azure Blob";
273
+ case "minio": return "MinIO";
274
+ case "s3": return "S3";
275
+ default: return;
276
+ }
277
+ }
278
+ getClient() {
279
+ if (this._client) return this._client;
280
+ const hasStaticCredentials = this.accessKeyId && this.secretAccessKey;
281
+ let credentials;
282
+ if (this.credentials) credentials = this.credentials;
283
+ else if (hasStaticCredentials) credentials = {
284
+ accessKeyId: this.accessKeyId,
285
+ secretAccessKey: this.secretAccessKey,
286
+ ...this.sessionToken && { sessionToken: this.sessionToken }
287
+ };
288
+ this._client = new _aws_sdk_client_s3.S3Client({
289
+ region: this.region,
290
+ ...credentials !== void 0 && { credentials },
291
+ endpoint: this.endpoint,
292
+ forcePathStyle: this.forcePathStyle
293
+ });
294
+ return this._client;
295
+ }
296
+ /**
297
+ * Ensure the filesystem is initialized and return the S3 client.
298
+ * Uses base class ensureReady() for status management, then returns client.
299
+ */
300
+ async getReadyClient() {
301
+ await this.ensureReady();
302
+ return this.getClient();
303
+ }
304
+ toKey(path) {
305
+ const cleanPath = path.replace(/^\/+/, "").replace(/^\.(?:\/|$)/, "");
306
+ return this.prefix + cleanPath;
307
+ }
308
+ async readFile(path, options) {
309
+ if (path.endsWith("/")) throw new _mastra_core_workspace.FileNotFoundError(path);
310
+ const client = await this.getReadyClient();
311
+ try {
312
+ const body = await (await client.send(new _aws_sdk_client_s3.GetObjectCommand({
313
+ Bucket: this.bucket,
314
+ Key: this.toKey(path)
315
+ }))).Body?.transformToByteArray();
316
+ if (!body) throw new _mastra_core_workspace.FileNotFoundError(path);
317
+ const buffer = Buffer.from(body);
318
+ if (options?.encoding) return buffer.toString(options.encoding);
319
+ return buffer;
320
+ } catch (error) {
321
+ if (isNotFoundError$1(error)) throw new _mastra_core_workspace.FileNotFoundError(path);
322
+ throw this.handleError(error);
323
+ }
324
+ }
325
+ async writeFile(path, content, options) {
326
+ const client = await this.getReadyClient();
327
+ if (options?.overwrite === false && await this.exists(path)) throw new _mastra_core_workspace.FileExistsError(path);
328
+ const body = typeof content === "string" ? Buffer.from(content, "utf-8") : Buffer.from(content);
329
+ const contentType = getMimeType(path);
330
+ await client.send(new _aws_sdk_client_s3.PutObjectCommand({
331
+ Bucket: this.bucket,
332
+ Key: this.toKey(path),
333
+ Body: body,
334
+ ContentType: contentType
335
+ }));
336
+ }
337
+ async appendFile(path, content) {
338
+ let existing = "";
339
+ try {
340
+ existing = await this.readFile(path, { encoding: "utf-8" });
341
+ } catch (error) {
342
+ if (error instanceof _mastra_core_workspace.FileNotFoundError) {} else throw error;
343
+ }
344
+ const appendContent = typeof content === "string" ? content : Buffer.from(content).toString("utf-8");
345
+ await this.writeFile(path, existing + appendContent);
346
+ }
347
+ async deleteFile(path, options) {
348
+ if (await this.isDirectory(path)) {
349
+ await this.rmdir(path, {
350
+ recursive: true,
351
+ force: options?.force
352
+ });
353
+ return;
354
+ }
355
+ const client = await this.getReadyClient();
356
+ try {
357
+ await client.send(new _aws_sdk_client_s3.DeleteObjectCommand({
358
+ Bucket: this.bucket,
359
+ Key: this.toKey(path)
360
+ }));
361
+ } catch (error) {
362
+ if (options?.force) return;
363
+ if (isNotFoundError$1(error)) throw new _mastra_core_workspace.FileNotFoundError(path);
364
+ throw this.handleError(error);
365
+ }
366
+ }
367
+ async copyFile(src, dest, options) {
368
+ if (src.endsWith("/")) throw new _mastra_core_workspace.FileNotFoundError(src);
369
+ const client = await this.getReadyClient();
370
+ if (options?.overwrite === false && await this.exists(dest)) throw new _mastra_core_workspace.FileExistsError(dest);
371
+ try {
372
+ await client.send(new _aws_sdk_client_s3.CopyObjectCommand({
373
+ Bucket: this.bucket,
374
+ CopySource: `${this.bucket}/${encodeURIComponent(this.toKey(src)).replace(/%2F/g, "/")}`,
375
+ Key: this.toKey(dest)
376
+ }));
377
+ } catch (error) {
378
+ if (isNotFoundError$1(error)) throw new _mastra_core_workspace.FileNotFoundError(src);
379
+ throw this.handleError(error);
380
+ }
381
+ }
382
+ async moveFile(src, dest, options) {
383
+ await this.copyFile(src, dest, options);
384
+ await this.deleteFile(src, { force: true });
385
+ }
386
+ async mkdir(path, _options) {
387
+ const key = trimSlashes$1(this.toKey(path));
388
+ if (!key || key + "/" === this.prefix) return;
389
+ const client = await this.getReadyClient();
390
+ try {
391
+ await client.send(new _aws_sdk_client_s3.HeadObjectCommand({
392
+ Bucket: this.bucket,
393
+ Key: key
394
+ }));
395
+ throw new _mastra_core_workspace.FileExistsError(path);
396
+ } catch (error) {
397
+ if (error instanceof _mastra_core_workspace.FileExistsError) throw error;
398
+ }
399
+ await client.send(new _aws_sdk_client_s3.PutObjectCommand({
400
+ Bucket: this.bucket,
401
+ Key: key + "/",
402
+ Body: /* @__PURE__ */ new Uint8Array(0)
403
+ }));
404
+ }
405
+ async rmdir(path, options) {
406
+ if (!options?.recursive) {
407
+ if ((await this.readdir(path)).length > 0) throw new Error(`Directory not empty: ${path}`);
408
+ const key = trimSlashes$1(this.toKey(path));
409
+ if (key && key + "/" !== this.prefix) await (await this.getReadyClient()).send(new _aws_sdk_client_s3.DeleteObjectCommand({
410
+ Bucket: this.bucket,
411
+ Key: key + "/"
412
+ }));
413
+ return;
414
+ }
415
+ const client = await this.getReadyClient();
416
+ const prefix = this.toKey(path).replace(/\/$/, "") + "/";
417
+ let continuationToken;
418
+ do {
419
+ const listResponse = await client.send(new _aws_sdk_client_s3.ListObjectsV2Command({
420
+ Bucket: this.bucket,
421
+ Prefix: prefix,
422
+ ContinuationToken: continuationToken
423
+ }));
424
+ if (listResponse.Contents && listResponse.Contents.length > 0) {
425
+ const deleteResponse = await client.send(new _aws_sdk_client_s3.DeleteObjectsCommand({
426
+ Bucket: this.bucket,
427
+ Delete: { Objects: listResponse.Contents.filter((obj) => !!obj.Key).map((obj) => ({ Key: obj.Key })) }
428
+ }));
429
+ if (deleteResponse.Errors && deleteResponse.Errors.length > 0) throw new Error(`Failed to delete ${deleteResponse.Errors.length} object(s) in ${path}`);
430
+ }
431
+ continuationToken = listResponse.NextContinuationToken;
432
+ } while (continuationToken);
433
+ }
434
+ async readdir(path, options) {
435
+ const client = await this.getReadyClient();
436
+ const prefix = this.toKey(path).replace(/\/$/, "");
437
+ const searchPrefix = prefix ? prefix + "/" : "";
438
+ const entries = [];
439
+ const seenDirs = /* @__PURE__ */ new Set();
440
+ let continuationToken;
441
+ do {
442
+ const response = await client.send(new _aws_sdk_client_s3.ListObjectsV2Command({
443
+ Bucket: this.bucket,
444
+ Prefix: searchPrefix,
445
+ Delimiter: options?.recursive ? void 0 : "/",
446
+ ContinuationToken: continuationToken
447
+ }));
448
+ if (response.Contents) for (const obj of response.Contents) {
449
+ const key = obj.Key;
450
+ if (!key || key === searchPrefix) continue;
451
+ const relativePath = key.slice(searchPrefix.length);
452
+ if (!relativePath) continue;
453
+ if (relativePath.endsWith("/")) {
454
+ if (options?.recursive && options.extension) continue;
455
+ const dirName = options?.recursive ? relativePath.slice(0, -1) : relativePath.split("/")[0];
456
+ if (!dirName) continue;
457
+ if (!seenDirs.has(dirName)) {
458
+ seenDirs.add(dirName);
459
+ entries.push({
460
+ name: dirName,
461
+ type: "directory"
462
+ });
463
+ }
464
+ continue;
465
+ }
466
+ const name = options?.recursive ? relativePath : relativePath.split("/")[0];
467
+ if (!name) continue;
468
+ if (options?.extension) {
469
+ if (!(Array.isArray(options.extension) ? options.extension : [options.extension]).some((ext) => name.endsWith(ext))) continue;
470
+ }
471
+ entries.push({
472
+ name,
473
+ type: "file",
474
+ size: obj.Size
475
+ });
476
+ }
477
+ if (response.CommonPrefixes) for (const prefixObj of response.CommonPrefixes) {
478
+ if (!prefixObj.Prefix) continue;
479
+ const dirName = prefixObj.Prefix.slice(searchPrefix.length).replace(/\/$/, "");
480
+ if (dirName && !seenDirs.has(dirName)) {
481
+ seenDirs.add(dirName);
482
+ entries.push({
483
+ name: dirName,
484
+ type: "directory"
485
+ });
486
+ }
487
+ }
488
+ continuationToken = response.NextContinuationToken;
489
+ } while (continuationToken);
490
+ return entries;
491
+ }
492
+ async exists(path) {
493
+ const key = this.toKey(path);
494
+ if (!key) return true;
495
+ const client = await this.getReadyClient();
496
+ try {
497
+ await client.send(new _aws_sdk_client_s3.HeadObjectCommand({
498
+ Bucket: this.bucket,
499
+ Key: key
500
+ }));
501
+ return true;
502
+ } catch (error) {
503
+ if (!isNotFoundError$1(error)) throw this.handleError(error);
504
+ }
505
+ return ((await client.send(new _aws_sdk_client_s3.ListObjectsV2Command({
506
+ Bucket: this.bucket,
507
+ Prefix: key.replace(/\/$/, "") + "/",
508
+ MaxKeys: 1
509
+ }))).Contents?.length ?? 0) > 0;
510
+ }
511
+ async stat(path) {
512
+ const key = trimSlashes$1(this.toKey(path));
513
+ const directoryOnly = path.endsWith("/");
514
+ if (!key) return {
515
+ name: "",
516
+ path,
517
+ type: "directory",
518
+ size: 0,
519
+ createdAt: /* @__PURE__ */ new Date(),
520
+ modifiedAt: /* @__PURE__ */ new Date()
521
+ };
522
+ const name = key.split("/").pop() ?? "";
523
+ if (!directoryOnly) {
524
+ const client = await this.getReadyClient();
525
+ try {
526
+ const response = await client.send(new _aws_sdk_client_s3.HeadObjectCommand({
527
+ Bucket: this.bucket,
528
+ Key: key
529
+ }));
530
+ return {
531
+ name,
532
+ path,
533
+ type: "file",
534
+ size: response.ContentLength ?? 0,
535
+ createdAt: response.LastModified ?? /* @__PURE__ */ new Date(),
536
+ modifiedAt: response.LastModified ?? /* @__PURE__ */ new Date()
537
+ };
538
+ } catch (error) {
539
+ if (!isNotFoundError$1(error)) throw this.handleError(error);
540
+ }
541
+ }
542
+ if (await this.isDirectory(path)) return {
543
+ name,
544
+ path,
545
+ type: "directory",
546
+ size: 0,
547
+ createdAt: /* @__PURE__ */ new Date(),
548
+ modifiedAt: /* @__PURE__ */ new Date()
549
+ };
550
+ throw new _mastra_core_workspace.FileNotFoundError(path);
551
+ }
552
+ async isFile(path) {
553
+ if (path.endsWith("/")) return false;
554
+ const key = trimSlashes$1(this.toKey(path));
555
+ if (!key) return false;
556
+ const client = await this.getReadyClient();
557
+ try {
558
+ await client.send(new _aws_sdk_client_s3.HeadObjectCommand({
559
+ Bucket: this.bucket,
560
+ Key: key
561
+ }));
562
+ return true;
563
+ } catch (error) {
564
+ if (!isNotFoundError$1(error)) throw this.handleError(error);
565
+ return false;
566
+ }
567
+ }
568
+ async isDirectory(path) {
569
+ const key = this.toKey(path);
570
+ if (!key) return true;
571
+ return ((await (await this.getReadyClient()).send(new _aws_sdk_client_s3.ListObjectsV2Command({
572
+ Bucket: this.bucket,
573
+ Prefix: key.replace(/\/$/, "") + "/",
574
+ MaxKeys: 1
575
+ }))).Contents?.length ?? 0) > 0;
576
+ }
577
+ /**
578
+ * Initialize the S3 client.
579
+ * Status management is handled by the base class.
580
+ */
581
+ async init() {
582
+ const client = this.getClient();
583
+ try {
584
+ await client.send(new _aws_sdk_client_s3.HeadBucketCommand({ Bucket: this.bucket }));
585
+ } catch (error) {
586
+ const statusCode = error.$metadata?.httpStatusCode;
587
+ const createError = (message) => {
588
+ const err = new Error(message);
589
+ if (statusCode) err.status = statusCode;
590
+ return err;
591
+ };
592
+ if (isAccessDeniedError(error)) throw createError(`Access denied to bucket "${this.bucket}" - check credentials and permissions`);
593
+ if (isNotFoundError$1(error)) throw createError(`Bucket "${this.bucket}" not found`);
594
+ const message = error instanceof Error ? error.message : String(error);
595
+ if (statusCode) throw createError(`Failed to access bucket "${this.bucket}" (HTTP ${statusCode}): ${message}`);
596
+ throw error;
597
+ }
598
+ }
599
+ /**
600
+ * Clean up the S3 client.
601
+ * Status management is handled by the base class.
602
+ */
603
+ async destroy() {
604
+ this._client = null;
605
+ }
628
606
  };
629
- function trimSlashes2(s) {
630
- let start = 0;
631
- let end = s.length;
632
- while (start < end && s[start] === "/") start++;
633
- while (end > start && s[end - 1] === "/") end--;
634
- return s.slice(start, end);
607
+ //#endregion
608
+ //#region src/blob-store/index.ts
609
+ /** Trim leading and trailing slashes. */
610
+ function trimSlashes(s) {
611
+ let start = 0;
612
+ let end = s.length;
613
+ while (start < end && s[start] === "/") start++;
614
+ while (end > start && s[end - 1] === "/") end--;
615
+ return s.slice(start, end);
635
616
  }
636
- var S3BlobStore = class extends storage.BlobStore {
637
- bucket;
638
- prefix;
639
- _client = null;
640
- region;
641
- credentials;
642
- accessKeyId;
643
- secretAccessKey;
644
- sessionToken;
645
- endpoint;
646
- forcePathStyle;
647
- constructor(options) {
648
- super();
649
- this.bucket = options.bucket;
650
- this.region = options.region;
651
- this.credentials = options.credentials;
652
- this.accessKeyId = options.accessKeyId;
653
- this.secretAccessKey = options.secretAccessKey;
654
- this.sessionToken = options.sessionToken;
655
- this.endpoint = options.endpoint;
656
- this.forcePathStyle = options.forcePathStyle ?? !!options.endpoint;
657
- this.prefix = options.prefix ? trimSlashes2(options.prefix) + "/" : "mastra_skill_blobs/";
658
- }
659
- getClient() {
660
- if (this._client) return this._client;
661
- const hasStaticCredentials = this.accessKeyId && this.secretAccessKey;
662
- let credentials;
663
- if (this.credentials) {
664
- credentials = this.credentials;
665
- } else if (hasStaticCredentials) {
666
- credentials = {
667
- accessKeyId: this.accessKeyId,
668
- secretAccessKey: this.secretAccessKey,
669
- ...this.sessionToken && { sessionToken: this.sessionToken }
670
- };
671
- }
672
- this._client = new clientS3.S3Client({
673
- region: this.region,
674
- ...credentials !== void 0 && { credentials },
675
- endpoint: this.endpoint,
676
- forcePathStyle: this.forcePathStyle
677
- });
678
- return this._client;
679
- }
680
- toKey(hash) {
681
- return this.prefix + hash;
682
- }
683
- async init() {
684
- }
685
- async put(entry) {
686
- const client = this.getClient();
687
- const now = entry.createdAt ?? /* @__PURE__ */ new Date();
688
- await client.send(
689
- new clientS3.PutObjectCommand({
690
- Bucket: this.bucket,
691
- Key: this.toKey(entry.hash),
692
- Body: entry.content,
693
- ContentType: entry.mimeType ?? "application/octet-stream",
694
- Metadata: {
695
- size: String(entry.size),
696
- createdat: now.toISOString(),
697
- ...entry.mimeType ? { mimetype: entry.mimeType } : {}
698
- }
699
- })
700
- );
701
- }
702
- async get(hash) {
703
- const client = this.getClient();
704
- try {
705
- const response = await client.send(
706
- new clientS3.GetObjectCommand({
707
- Bucket: this.bucket,
708
- Key: this.toKey(hash)
709
- })
710
- );
711
- const body = await response.Body?.transformToString("utf-8");
712
- if (body === void 0 || body === null) return null;
713
- const metadata = response.Metadata ?? {};
714
- return {
715
- hash,
716
- content: body,
717
- size: metadata.size != null ? Number(metadata.size) : Buffer.byteLength(body, "utf-8"),
718
- mimeType: metadata.mimetype || response.ContentType || void 0,
719
- createdAt: metadata.createdat ? new Date(metadata.createdat) : /* @__PURE__ */ new Date()
720
- };
721
- } catch (error) {
722
- if (isNotFoundError2(error)) return null;
723
- throw error;
724
- }
725
- }
726
- async has(hash) {
727
- const client = this.getClient();
728
- try {
729
- await client.send(
730
- new clientS3.HeadObjectCommand({
731
- Bucket: this.bucket,
732
- Key: this.toKey(hash)
733
- })
734
- );
735
- return true;
736
- } catch (error) {
737
- if (isNotFoundError2(error)) return false;
738
- throw error;
739
- }
740
- }
741
- async delete(hash) {
742
- const existed = await this.has(hash);
743
- if (!existed) return false;
744
- const client = this.getClient();
745
- await client.send(
746
- new clientS3.DeleteObjectCommand({
747
- Bucket: this.bucket,
748
- Key: this.toKey(hash)
749
- })
750
- );
751
- return true;
752
- }
753
- async putMany(entries) {
754
- if (entries.length === 0) return;
755
- await Promise.all(entries.map((entry) => this.put(entry)));
756
- }
757
- async getMany(hashes) {
758
- const result = /* @__PURE__ */ new Map();
759
- if (hashes.length === 0) return result;
760
- const entries = await Promise.all(hashes.map((hash) => this.get(hash)));
761
- for (const entry of entries) {
762
- if (entry) {
763
- result.set(entry.hash, entry);
764
- }
765
- }
766
- return result;
767
- }
768
- async dangerouslyClearAll() {
769
- const client = this.getClient();
770
- let continuationToken;
771
- do {
772
- const listResponse = await client.send(
773
- new clientS3.ListObjectsV2Command({
774
- Bucket: this.bucket,
775
- Prefix: this.prefix,
776
- ContinuationToken: continuationToken
777
- })
778
- );
779
- const objects = listResponse.Contents;
780
- if (objects && objects.length > 0) {
781
- await client.send(
782
- new clientS3.DeleteObjectsCommand({
783
- Bucket: this.bucket,
784
- Delete: {
785
- Objects: objects.filter((obj) => obj.Key != null).map((obj) => ({ Key: obj.Key })),
786
- Quiet: true
787
- }
788
- })
789
- );
790
- }
791
- continuationToken = listResponse.IsTruncated ? listResponse.NextContinuationToken : void 0;
792
- } while (continuationToken);
793
- }
617
+ /**
618
+ * S3-backed content-addressable blob store for skill versioning.
619
+ *
620
+ * Each blob is stored as an S3 object keyed by its SHA-256 hash.
621
+ * Metadata (size, mimeType, createdAt) is stored in S3 object user metadata.
622
+ *
623
+ * Since blobs are content-addressable, writes are idempotent — the same hash
624
+ * always maps to the same content, so overwrites are safe and equivalent to
625
+ * a no-op.
626
+ *
627
+ * @example AWS S3
628
+ * ```typescript
629
+ * import { S3BlobStore } from '@mastra/s3';
630
+ *
631
+ * const blobs = new S3BlobStore({
632
+ * bucket: 'my-skill-blobs',
633
+ * region: 'us-east-1',
634
+ * accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
635
+ * secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
636
+ * });
637
+ * ```
638
+ *
639
+ * @example MinIO (local)
640
+ * ```typescript
641
+ * import { S3BlobStore } from '@mastra/s3';
642
+ *
643
+ * const blobs = new S3BlobStore({
644
+ * bucket: 'skill-blobs',
645
+ * region: 'us-east-1',
646
+ * accessKeyId: 'minioadmin',
647
+ * secretAccessKey: 'minioadmin',
648
+ * endpoint: 'http://localhost:9000',
649
+ * forcePathStyle: true,
650
+ * });
651
+ * ```
652
+ */
653
+ var S3BlobStore = class extends _mastra_core_storage.BlobStore {
654
+ bucket;
655
+ prefix;
656
+ _client = null;
657
+ region;
658
+ credentials;
659
+ accessKeyId;
660
+ secretAccessKey;
661
+ sessionToken;
662
+ endpoint;
663
+ forcePathStyle;
664
+ constructor(options) {
665
+ super();
666
+ this.bucket = options.bucket;
667
+ this.region = options.region;
668
+ this.credentials = options.credentials;
669
+ this.accessKeyId = options.accessKeyId;
670
+ this.secretAccessKey = options.secretAccessKey;
671
+ this.sessionToken = options.sessionToken;
672
+ this.endpoint = options.endpoint;
673
+ this.forcePathStyle = options.forcePathStyle ?? !!options.endpoint;
674
+ this.prefix = options.prefix ? trimSlashes(options.prefix) + "/" : "mastra_skill_blobs/";
675
+ }
676
+ getClient() {
677
+ if (this._client) return this._client;
678
+ const hasStaticCredentials = this.accessKeyId && this.secretAccessKey;
679
+ let credentials;
680
+ if (this.credentials) credentials = this.credentials;
681
+ else if (hasStaticCredentials) credentials = {
682
+ accessKeyId: this.accessKeyId,
683
+ secretAccessKey: this.secretAccessKey,
684
+ ...this.sessionToken && { sessionToken: this.sessionToken }
685
+ };
686
+ this._client = new _aws_sdk_client_s3.S3Client({
687
+ region: this.region,
688
+ ...credentials !== void 0 && { credentials },
689
+ endpoint: this.endpoint,
690
+ forcePathStyle: this.forcePathStyle
691
+ });
692
+ return this._client;
693
+ }
694
+ toKey(hash) {
695
+ return this.prefix + hash;
696
+ }
697
+ async init() {}
698
+ async put(entry) {
699
+ const client = this.getClient();
700
+ const now = entry.createdAt ?? /* @__PURE__ */ new Date();
701
+ await client.send(new _aws_sdk_client_s3.PutObjectCommand({
702
+ Bucket: this.bucket,
703
+ Key: this.toKey(entry.hash),
704
+ Body: entry.content,
705
+ ContentType: entry.mimeType ?? "application/octet-stream",
706
+ Metadata: {
707
+ size: String(entry.size),
708
+ createdat: now.toISOString(),
709
+ ...entry.mimeType ? { mimetype: entry.mimeType } : {}
710
+ }
711
+ }));
712
+ }
713
+ async get(hash) {
714
+ const client = this.getClient();
715
+ try {
716
+ const response = await client.send(new _aws_sdk_client_s3.GetObjectCommand({
717
+ Bucket: this.bucket,
718
+ Key: this.toKey(hash)
719
+ }));
720
+ const body = await response.Body?.transformToString("utf-8");
721
+ if (body === void 0 || body === null) return null;
722
+ const metadata = response.Metadata ?? {};
723
+ return {
724
+ hash,
725
+ content: body,
726
+ size: metadata.size != null ? Number(metadata.size) : Buffer.byteLength(body, "utf-8"),
727
+ mimeType: metadata.mimetype || response.ContentType || void 0,
728
+ createdAt: metadata.createdat ? new Date(metadata.createdat) : /* @__PURE__ */ new Date()
729
+ };
730
+ } catch (error) {
731
+ if (isNotFoundError(error)) return null;
732
+ throw error;
733
+ }
734
+ }
735
+ async has(hash) {
736
+ const client = this.getClient();
737
+ try {
738
+ await client.send(new _aws_sdk_client_s3.HeadObjectCommand({
739
+ Bucket: this.bucket,
740
+ Key: this.toKey(hash)
741
+ }));
742
+ return true;
743
+ } catch (error) {
744
+ if (isNotFoundError(error)) return false;
745
+ throw error;
746
+ }
747
+ }
748
+ async delete(hash) {
749
+ if (!await this.has(hash)) return false;
750
+ await this.getClient().send(new _aws_sdk_client_s3.DeleteObjectCommand({
751
+ Bucket: this.bucket,
752
+ Key: this.toKey(hash)
753
+ }));
754
+ return true;
755
+ }
756
+ async putMany(entries) {
757
+ if (entries.length === 0) return;
758
+ await Promise.all(entries.map((entry) => this.put(entry)));
759
+ }
760
+ async getMany(hashes) {
761
+ const result = /* @__PURE__ */ new Map();
762
+ if (hashes.length === 0) return result;
763
+ const entries = await Promise.all(hashes.map((hash) => this.get(hash)));
764
+ for (const entry of entries) if (entry) result.set(entry.hash, entry);
765
+ return result;
766
+ }
767
+ async dangerouslyClearAll() {
768
+ const client = this.getClient();
769
+ let continuationToken;
770
+ do {
771
+ const listResponse = await client.send(new _aws_sdk_client_s3.ListObjectsV2Command({
772
+ Bucket: this.bucket,
773
+ Prefix: this.prefix,
774
+ ContinuationToken: continuationToken
775
+ }));
776
+ const objects = listResponse.Contents;
777
+ if (objects && objects.length > 0) await client.send(new _aws_sdk_client_s3.DeleteObjectsCommand({
778
+ Bucket: this.bucket,
779
+ Delete: {
780
+ Objects: objects.filter((obj) => obj.Key != null).map((obj) => ({ Key: obj.Key })),
781
+ Quiet: true
782
+ }
783
+ }));
784
+ continuationToken = listResponse.IsTruncated ? listResponse.NextContinuationToken : void 0;
785
+ } while (continuationToken);
786
+ }
794
787
  };
795
- function isNotFoundError2(error) {
796
- if (!error || typeof error !== "object" || !("name" in error)) return false;
797
- const name = error.name;
798
- return name === "NotFound" || name === "NoSuchKey" || name === "404";
788
+ function isNotFoundError(error) {
789
+ if (!error || typeof error !== "object" || !("name" in error)) return false;
790
+ const name = error.name;
791
+ return name === "NotFound" || name === "NoSuchKey" || name === "404";
799
792
  }
800
-
801
- // src/provider.ts
802
- var s3FilesystemProvider = {
803
- id: "s3",
804
- name: "Amazon S3",
805
- description: "S3 or S3-compatible storage (AWS, R2, MinIO, DO Spaces)",
806
- configSchema: {
807
- type: "object",
808
- required: ["bucket", "region"],
809
- properties: {
810
- bucket: { type: "string", description: "S3 bucket name" },
811
- region: { type: "string", description: 'AWS region (use "auto" for R2)' },
812
- accessKeyId: { type: "string", description: "AWS access key ID" },
813
- secretAccessKey: { type: "string", description: "AWS secret access key" },
814
- sessionToken: { type: "string", description: "AWS session token for temporary credentials" },
815
- endpoint: { type: "string", description: "Custom endpoint URL for S3-compatible storage" },
816
- forcePathStyle: { type: "boolean", description: "Force path-style URLs", default: false },
817
- prefix: { type: "string", description: "Key prefix (acts like a subdirectory)" },
818
- readOnly: { type: "boolean", description: "Mount as read-only", default: false }
819
- }
820
- },
821
- createFilesystem: (config) => new S3Filesystem(config)
793
+ //#endregion
794
+ //#region src/provider.ts
795
+ const s3FilesystemProvider = {
796
+ id: "s3",
797
+ name: "Amazon S3",
798
+ description: "S3 or S3-compatible storage (AWS, R2, MinIO, DO Spaces)",
799
+ configSchema: {
800
+ type: "object",
801
+ required: ["bucket", "region"],
802
+ properties: {
803
+ bucket: {
804
+ type: "string",
805
+ description: "S3 bucket name"
806
+ },
807
+ region: {
808
+ type: "string",
809
+ description: "AWS region (use \"auto\" for R2)"
810
+ },
811
+ accessKeyId: {
812
+ type: "string",
813
+ description: "AWS access key ID"
814
+ },
815
+ secretAccessKey: {
816
+ type: "string",
817
+ description: "AWS secret access key"
818
+ },
819
+ sessionToken: {
820
+ type: "string",
821
+ description: "AWS session token for temporary credentials"
822
+ },
823
+ endpoint: {
824
+ type: "string",
825
+ description: "Custom endpoint URL for S3-compatible storage"
826
+ },
827
+ forcePathStyle: {
828
+ type: "boolean",
829
+ description: "Force path-style URLs",
830
+ default: false
831
+ },
832
+ prefix: {
833
+ type: "string",
834
+ description: "Key prefix (acts like a subdirectory)"
835
+ },
836
+ readOnly: {
837
+ type: "boolean",
838
+ description: "Mount as read-only",
839
+ default: false
840
+ }
841
+ }
842
+ },
843
+ createFilesystem: (config) => new S3Filesystem(config)
822
844
  };
823
- var s3BlobStoreProvider = {
824
- id: "s3",
825
- name: "Amazon S3 Blob Store",
826
- description: "Content-addressable blob storage using S3 or S3-compatible storage (AWS, R2, MinIO, DO Spaces)",
827
- configSchema: {
828
- type: "object",
829
- required: ["bucket", "region", "accessKeyId", "secretAccessKey"],
830
- properties: {
831
- bucket: { type: "string", description: "S3 bucket name" },
832
- region: { type: "string", description: 'AWS region (use "auto" for R2)' },
833
- accessKeyId: { type: "string", description: "AWS access key ID" },
834
- secretAccessKey: { type: "string", description: "AWS secret access key" },
835
- sessionToken: { type: "string", description: "AWS session token for temporary credentials" },
836
- endpoint: { type: "string", description: "Custom endpoint URL for S3-compatible storage" },
837
- forcePathStyle: { type: "boolean", description: "Force path-style URLs", default: false },
838
- prefix: { type: "string", description: "Key prefix for blob objects (default: mastra_skill_blobs/)" }
839
- }
840
- },
841
- createBlobStore: (config) => new S3BlobStore(config)
845
+ /**
846
+ * S3 blob store provider descriptor for MastraEditor.
847
+ *
848
+ * @example
849
+ * ```typescript
850
+ * import { s3BlobStoreProvider } from '@mastra/s3';
851
+ *
852
+ * const editor = new MastraEditor({
853
+ * blobStores: { s3: s3BlobStoreProvider },
854
+ * });
855
+ * ```
856
+ */
857
+ const s3BlobStoreProvider = {
858
+ id: "s3",
859
+ name: "Amazon S3 Blob Store",
860
+ description: "Content-addressable blob storage using S3 or S3-compatible storage (AWS, R2, MinIO, DO Spaces)",
861
+ configSchema: {
862
+ type: "object",
863
+ required: [
864
+ "bucket",
865
+ "region",
866
+ "accessKeyId",
867
+ "secretAccessKey"
868
+ ],
869
+ properties: {
870
+ bucket: {
871
+ type: "string",
872
+ description: "S3 bucket name"
873
+ },
874
+ region: {
875
+ type: "string",
876
+ description: "AWS region (use \"auto\" for R2)"
877
+ },
878
+ accessKeyId: {
879
+ type: "string",
880
+ description: "AWS access key ID"
881
+ },
882
+ secretAccessKey: {
883
+ type: "string",
884
+ description: "AWS secret access key"
885
+ },
886
+ sessionToken: {
887
+ type: "string",
888
+ description: "AWS session token for temporary credentials"
889
+ },
890
+ endpoint: {
891
+ type: "string",
892
+ description: "Custom endpoint URL for S3-compatible storage"
893
+ },
894
+ forcePathStyle: {
895
+ type: "boolean",
896
+ description: "Force path-style URLs",
897
+ default: false
898
+ },
899
+ prefix: {
900
+ type: "string",
901
+ description: "Key prefix for blob objects (default: mastra_skill_blobs/)"
902
+ }
903
+ }
904
+ },
905
+ createBlobStore: (config) => new S3BlobStore(config)
842
906
  };
843
-
907
+ //#endregion
844
908
  exports.S3BlobStore = S3BlobStore;
845
909
  exports.S3Filesystem = S3Filesystem;
846
910
  exports.s3BlobStoreProvider = s3BlobStoreProvider;
847
911
  exports.s3FilesystemProvider = s3FilesystemProvider;
848
- //# sourceMappingURL=index.cjs.map
912
+
849
913
  //# sourceMappingURL=index.cjs.map