@framers/agentos-ext-tool-media-upload 0.1.0 → 0.1.2

package/manifest.json

@@ -2,16 +2,16 @@
   "$schema": "https://agentos.sh/schemas/extension-manifest-v1.json",
   "id": "com.framers.tools.media-upload",
   "name": "Media Upload Tool",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Upload images, videos, and audio files to the media library for use in social posts. Returns an asset ID that can be referenced in post tools.",
   "author": {
     "name": "Frame.dev",
     "email": "support@frame.dev",
-    "url": "https://github.com/framersai"
+    "url": "https://github.com/framerslab"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "keywords": ["social", "media", "upload", "images", "video", "audio", "asset-management"],
-  "agentosVersion": "^2.0.0",
+  "agentosVersion": ">=0.10.40",
   "categories": ["tool", "social"],
   "platforms": [],
   "sdk": "none",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@framers/agentos-ext-tool-media-upload",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Media upload tool — upload images, videos, and audio to the media library for use in social posts.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,33 +34,40 @@
       "url": "https://github.com/jddunn"
     }
   ],
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/framersai/agentos-extensions.git",
+    "url": "git+https://github.com/framerslab/agentos-extensions.git",
     "directory": "registry/curated/tools/media-upload"
   },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
-    "@framers/agentos": "^0.5.2"
+    "@framers/agentos": ">=0.10.40"
   },
   "devDependencies": {
-    "@framers/agentos": "^0.6.6",
     "@types/node": "^20.12.12",
-    "@vitest/coverage-v8": "^1.6.0",
+    "@vitest/coverage-v8": "^3.2.7",
     "rimraf": "^5.0.7",
     "typescript": "^5.4.5",
-    "vitest": "^1.6.0"
+    "vitest": "^3.2.7",
+    "@framers/agentos": "^0.13.40"
   },
+  "homepage": "https://github.com/framerslab/agentos-extensions/tree/master/registry/curated/tools/media-upload#readme",
+  "bugs": {
+    "url": "https://github.com/framerslab/agentos-extensions/issues"
+  },
+  "files": [
+    "dist",
+    "manifest.json"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "vitest run",
+    "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
     "clean": "rimraf dist"
   }

package/src/MediaUploadTool.ts

@@ -1,213 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview Media Upload Tool — upload files to the media library for social posts.
- *
- * Reads a local file, detects MIME type, and returns an asset ID that can be
- * referenced in other post tools (e.g. multiChannelPost, twitterPost, etc.).
- */
-
-/* ------------------------------------------------------------------ */
-/*  Types                                                              */
-/* ------------------------------------------------------------------ */
-
-export interface MediaUploadInput {
-  /** Path to the media file to upload. */
-  filePath: string;
-  /** Tags for organizing the asset in the media library. */
-  tags?: string[];
-  /** Agent seed ID (owner). Defaults to current agent if omitted. */
-  seedId?: string;
-}
-
-export interface MediaUploadOutput {
-  assetId: string;
-  filename: string;
-  mimeType: string;
-  size: number;
-  tags: string[];
-  message: string;
-}
-
-/* ------------------------------------------------------------------ */
-/*  MIME map                                                            */
-/* ------------------------------------------------------------------ */
-
-const MIME_MAP: Record<string, string> = {
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.png': 'image/png',
-  '.gif': 'image/gif',
-  '.webp': 'image/webp',
-  '.svg': 'image/svg+xml',
-  '.mp4': 'video/mp4',
-  '.mov': 'video/quicktime',
-  '.webm': 'video/webm',
-  '.mp3': 'audio/mpeg',
-  '.wav': 'audio/wav',
-  '.ogg': 'audio/ogg',
-  '.pdf': 'application/pdf',
-};
-
-/* ------------------------------------------------------------------ */
-/*  Supported media type sets                                          */
-/* ------------------------------------------------------------------ */
-
-const SUPPORTED_IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg']);
-const SUPPORTED_VIDEO_EXTS = new Set(['.mp4', '.mov', '.webm']);
-const SUPPORTED_AUDIO_EXTS = new Set(['.mp3', '.wav', '.ogg']);
-
-/** Maximum file size: 100 MB */
-const MAX_FILE_SIZE = 100 * 1024 * 1024;
-
-/* ------------------------------------------------------------------ */
-/*  Tool executor callback type                                        */
-/* ------------------------------------------------------------------ */
-
-export type ToolExecutorFn = (
-  toolName: string,
-  args: Record<string, unknown>,
-) => Promise<{ success: boolean; data?: Record<string, unknown>; error?: string }>;
-
-/* ------------------------------------------------------------------ */
-/*  MediaUploadTool                                                    */
-/* ------------------------------------------------------------------ */
-
-export class MediaUploadTool {
-  readonly id = 'mediaUpload';
-  readonly name = 'mediaUpload';
-  readonly displayName = 'Upload Media';
-  readonly description =
-    'Upload an image, video, or audio file to the media library for use in social posts. ' +
-    'Returns an asset ID that can be referenced in post tools (multiChannelPost, twitterPost, etc.). ' +
-    'Supported formats: JPEG, PNG, GIF, WebP, SVG, MP4, MOV, WebM, MP3, WAV, OGG.';
-  readonly category = 'social';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = true;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      filePath: {
-        type: 'string',
-        description: 'Absolute or relative path to the media file to upload',
-      },
-      tags: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Tags for organizing the asset in the media library',
-      },
-      seedId: {
-        type: 'string',
-        description: 'Agent seed ID (owner). Defaults to current agent if omitted',
-      },
-    },
-    required: ['filePath'],
-  };
-
-  /* -------------------------------------------------------------- */
-  /*  Tool executor — set by the orchestrator that loads this ext    */
-  /* -------------------------------------------------------------- */
-
-  private toolExecutor?: ToolExecutorFn;
-
-  setToolExecutor(executor: ToolExecutorFn): void {
-    this.toolExecutor = executor;
-  }
-
-  /* -------------------------------------------------------------- */
-  /*  execute()                                                      */
-  /* -------------------------------------------------------------- */
-
-  async execute(
-    args: MediaUploadInput,
-  ): Promise<{ success: boolean; data?: MediaUploadOutput; error?: string }> {
-    try {
-      const fs = await import('fs/promises');
-      const nodePath = await import('path');
-      const crypto = await import('crypto');
-
-      // Resolve and validate file path
-      const resolvedPath = nodePath.resolve(args.filePath);
-
-      // Check file exists
-      try {
-        await fs.access(resolvedPath);
-      } catch {
-        return {
-          success: false,
-          error: `File not found: ${resolvedPath}`,
-        };
-      }
-
-      // Read file stats
-      const stat = await fs.stat(resolvedPath);
-      if (!stat.isFile()) {
-        return {
-          success: false,
-          error: `Path is not a file: ${resolvedPath}`,
-        };
-      }
-
-      if (stat.size > MAX_FILE_SIZE) {
-        return {
-          success: false,
-          error: `File too large: ${(stat.size / (1024 * 1024)).toFixed(1)} MB exceeds ${MAX_FILE_SIZE / (1024 * 1024)} MB limit`,
-        };
-      }
-
-      // Detect MIME type from extension
-      const ext = nodePath.extname(resolvedPath).toLowerCase();
-      const mimeType = MIME_MAP[ext] ?? 'application/octet-stream';
-
-      if (
-        !SUPPORTED_IMAGE_EXTS.has(ext) &&
-        !SUPPORTED_VIDEO_EXTS.has(ext) &&
-        !SUPPORTED_AUDIO_EXTS.has(ext) &&
-        ext !== '.pdf'
-      ) {
-        return {
-          success: false,
-          error: `Unsupported file type: ${ext}. Supported: ${[
-            ...SUPPORTED_IMAGE_EXTS,
-            ...SUPPORTED_VIDEO_EXTS,
-            ...SUPPORTED_AUDIO_EXTS,
-            '.pdf',
-          ].join(', ')}`,
-        };
-      }
-
-      // Read file into buffer
-      const buffer = await fs.readFile(resolvedPath);
-      const originalName = nodePath.basename(resolvedPath);
-
-      // Generate asset ID
-      const assetId = crypto.randomUUID();
-
-      // Determine media category for the message
-      let mediaCategory = 'file';
-      if (SUPPORTED_IMAGE_EXTS.has(ext)) mediaCategory = 'image';
-      else if (SUPPORTED_VIDEO_EXTS.has(ext)) mediaCategory = 'video';
-      else if (SUPPORTED_AUDIO_EXTS.has(ext)) mediaCategory = 'audio';
-
-      const tags = args.tags ?? [];
-      const sizeKb = (buffer.length / 1024).toFixed(1);
-
-      return {
-        success: true,
-        data: {
-          assetId,
-          filename: originalName,
-          mimeType,
-          size: buffer.length,
-          tags,
-          message:
-            `Media ${mediaCategory} uploaded: ${originalName} (${mimeType}, ${sizeKb} KB). ` +
-            `Use assetId "${assetId}" in post tools.`,
-        },
-      };
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { success: false, error: message };
-    }
-  }
-}

package/src/index.ts

@@ -1,66 +0,0 @@
-// @ts-nocheck
-/**
- * Media Upload Extension Pack — upload media files to the library for social posts.
- */
-
-import { MediaUploadTool } from './MediaUploadTool.js';
-
-/* ------------------------------------------------------------------ */
-/*  Extension pack types                                               */
-/* ------------------------------------------------------------------ */
-
-export interface ExtensionContext {
-  options?: Record<string, unknown>;
-  secrets?: Record<string, string>;
-  getSecret?: (key: string) => string | undefined;
-  logger?: { info: (msg: string) => void };
-}
-
-export interface ExtensionPack {
-  name: string;
-  version: string;
-  descriptors: Array<{
-    id: string;
-    kind: string;
-    priority?: number;
-    payload: unknown;
-  }>;
-  onActivate?: () => Promise<void>;
-  onDeactivate?: () => Promise<void>;
-}
-
-/* ------------------------------------------------------------------ */
-/*  Factory                                                            */
-/* ------------------------------------------------------------------ */
-
-export function createExtensionPack(context: ExtensionContext): ExtensionPack {
-  const tool = new MediaUploadTool();
-
-  return {
-    name: '@framers/agentos-ext-tool-media-upload',
-    version: '0.1.0',
-    descriptors: [
-      {
-        id: tool.name,
-        kind: 'tool' as const,
-        priority: 50,
-        payload: tool,
-      },
-    ],
-    onActivate: async () => context.logger?.info('Media Upload Extension activated'),
-    onDeactivate: async () => context.logger?.info('Media Upload Extension deactivated'),
-  };
-}
-
-/* ------------------------------------------------------------------ */
-/*  Re-exports                                                         */
-/* ------------------------------------------------------------------ */
-
-export { MediaUploadTool } from './MediaUploadTool.js';
-export type {
-  MediaUploadInput,
-  MediaUploadOutput,
-  ToolExecutorFn,
-} from './MediaUploadTool.js';
-
-export default createExtensionPack;

package/test/MediaUploadTool.spec.ts

@@ -1,344 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview Unit tests for MediaUploadTool.
- *
- * Tests cover: tool metadata, file existence validation, file size checks,
- * MIME type detection, unsupported extension rejection, asset ID generation,
- * directory path rejection, and error handling.
- *
- * The fs/promises, path, and crypto modules are mocked via vi.mock to
- * avoid touching the real filesystem.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MediaUploadTool, type MediaUploadInput } from '../src/MediaUploadTool.js';
-
-/* ------------------------------------------------------------------ */
-/*  Module mocks                                                       */
-/* ------------------------------------------------------------------ */
-
-const { mockAccess, mockStat, mockReadFile } = vi.hoisted(() => {
-  const mockAccess = vi.fn();
-  const mockStat = vi.fn();
-  const mockReadFile = vi.fn();
-  return { mockAccess, mockStat, mockReadFile };
-});
-
-vi.mock('fs/promises', () => ({
-  default: {
-    access: (...args: any[]) => mockAccess(...args),
-    stat: (...args: any[]) => mockStat(...args),
-    readFile: (...args: any[]) => mockReadFile(...args),
-  },
-  access: (...args: any[]) => mockAccess(...args),
-  stat: (...args: any[]) => mockStat(...args),
-  readFile: (...args: any[]) => mockReadFile(...args),
-}));
-
-vi.mock('path', () => ({
-  default: {
-    resolve: (p: string) => (p.startsWith('/') ? p : `/cwd/${p}`),
-    extname: (p: string) => {
-      const dot = p.lastIndexOf('.');
-      return dot >= 0 ? p.substring(dot) : '';
-    },
-    basename: (p: string) => p.split('/').pop() ?? p,
-  },
-  resolve: (p: string) => (p.startsWith('/') ? p : `/cwd/${p}`),
-  extname: (p: string) => {
-    const dot = p.lastIndexOf('.');
-    return dot >= 0 ? p.substring(dot) : '';
-  },
-  basename: (p: string) => p.split('/').pop() ?? p,
-}));
-
-vi.mock('crypto', () => ({
-  default: {
-    randomUUID: () => 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
-  },
-  randomUUID: () => 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
-}));
-
-/* ------------------------------------------------------------------ */
-/*  Helpers                                                            */
-/* ------------------------------------------------------------------ */
-
-function setupValidFile(ext: string, sizeBytes: number) {
-  mockAccess.mockResolvedValue(undefined);
-  mockStat.mockResolvedValue({ isFile: () => true, size: sizeBytes });
-  mockReadFile.mockResolvedValue(Buffer.alloc(sizeBytes));
-}
-
-/* ------------------------------------------------------------------ */
-/*  Tests                                                              */
-/* ------------------------------------------------------------------ */
-
-describe('MediaUploadTool', () => {
-  let tool: MediaUploadTool;
-
-  beforeEach(() => {
-    tool = new MediaUploadTool();
-    vi.clearAllMocks();
-  });
-
-  /* ── Metadata ─────────────────────────────────────────────────── */
-
-  describe('metadata', () => {
-    it('should expose the correct id and name', () => {
-      expect(tool.id).toBe('mediaUpload');
-      expect(tool.name).toBe('mediaUpload');
-    });
-
-    it('should require filePath in the input schema', () => {
-      expect(tool.inputSchema.required).toEqual(['filePath']);
-    });
-
-    it('should flag hasSideEffects as true', () => {
-      expect(tool.hasSideEffects).toBe(true);
-    });
-
-    it('should include a description mentioning supported formats', () => {
-      expect(tool.description).toContain('JPEG');
-      expect(tool.description).toContain('MP4');
-    });
-  });
-
-  /* ── File existence validation ────────────────────────────────── */
-
-  describe('file existence', () => {
-    it('should return error when file does not exist', async () => {
-      mockAccess.mockRejectedValue(new Error('ENOENT'));
-
-      const result = await tool.execute({ filePath: '/missing/file.jpg' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('File not found');
-      expect(result.error).toContain('/missing/file.jpg');
-    });
-
-    it('should resolve relative paths before checking existence', async () => {
-      mockAccess.mockRejectedValue(new Error('ENOENT'));
-
-      const result = await tool.execute({ filePath: 'relative/photo.png' });
-
-      expect(result.success).toBe(false);
-      // The error should contain the resolved absolute path
-      expect(result.error).toContain('/cwd/relative/photo.png');
-    });
-  });
-
-  /* ── Directory rejection ──────────────────────────────────────── */
-
-  describe('directory rejection', () => {
-    it('should return error when path points to a directory', async () => {
-      mockAccess.mockResolvedValue(undefined);
-      mockStat.mockResolvedValue({ isFile: () => false, size: 4096 });
-
-      const result = await tool.execute({ filePath: '/some/directory.jpg' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('not a file');
-    });
-  });
-
-  /* ── File size checks ─────────────────────────────────────────── */
-
-  describe('file size validation', () => {
-    it('should reject files larger than 100 MB', async () => {
-      const oversized = 101 * 1024 * 1024; // 101 MB
-      setupValidFile('.jpg', oversized);
-
-      const result = await tool.execute({ filePath: '/big/photo.jpg' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('File too large');
-      expect(result.error).toContain('100 MB limit');
-    });
-
-    it('should accept files exactly at the 100 MB limit', async () => {
-      const exactLimit = 100 * 1024 * 1024;
-      setupValidFile('.jpg', exactLimit);
-
-      const result = await tool.execute({ filePath: '/exact/photo.jpg' });
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should accept small files', async () => {
-      setupValidFile('.png', 1024);
-
-      const result = await tool.execute({ filePath: '/small/icon.png' });
-
-      expect(result.success).toBe(true);
-      expect(result.data!.size).toBe(1024);
-    });
-  });
-
-  /* ── MIME type detection ──────────────────────────────────────── */
-
-  describe('MIME type detection', () => {
-    const cases: Array<[string, string]> = [
-      ['.jpg', 'image/jpeg'],
-      ['.jpeg', 'image/jpeg'],
-      ['.png', 'image/png'],
-      ['.gif', 'image/gif'],
-      ['.webp', 'image/webp'],
-      ['.svg', 'image/svg+xml'],
-      ['.mp4', 'video/mp4'],
-      ['.mov', 'video/quicktime'],
-      ['.webm', 'video/webm'],
-      ['.mp3', 'audio/mpeg'],
-      ['.wav', 'audio/wav'],
-      ['.ogg', 'audio/ogg'],
-      ['.pdf', 'application/pdf'],
-    ];
-
-    for (const [ext, expectedMime] of cases) {
-      it(`should detect ${ext} as ${expectedMime}`, async () => {
-        setupValidFile(ext, 2048);
-
-        const result = await tool.execute({ filePath: `/test/file${ext}` });
-
-        expect(result.success).toBe(true);
-        expect(result.data!.mimeType).toBe(expectedMime);
-      });
-    }
-  });
-
-  /* ── Unsupported extension rejection ──────────────────────────── */
-
-  describe('unsupported file types', () => {
-    it('should reject .exe files', async () => {
-      setupValidFile('.exe', 2048);
-
-      const result = await tool.execute({ filePath: '/test/malware.exe' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Unsupported file type');
-      expect(result.error).toContain('.exe');
-    });
-
-    it('should reject .zip files', async () => {
-      setupValidFile('.zip', 2048);
-
-      const result = await tool.execute({ filePath: '/test/archive.zip' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Unsupported file type');
-    });
-
-    it('should list supported extensions in the error message', async () => {
-      setupValidFile('.txt', 2048);
-
-      const result = await tool.execute({ filePath: '/test/readme.txt' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('.jpg');
-      expect(result.error).toContain('.mp4');
-      expect(result.error).toContain('.mp3');
-      expect(result.error).toContain('.pdf');
-    });
-  });
-
-  /* ── Asset ID generation ──────────────────────────────────────── */
-
-  describe('asset ID and output', () => {
-    it('should return a UUID asset ID', async () => {
-      setupValidFile('.png', 4096);
-
-      const result = await tool.execute({ filePath: '/test/image.png' });
-
-      expect(result.success).toBe(true);
-      expect(result.data!.assetId).toBe('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee');
-    });
-
-    it('should return the original filename', async () => {
-      setupValidFile('.jpg', 4096);
-
-      const result = await tool.execute({ filePath: '/path/to/my-photo.jpg' });
-
-      expect(result.data!.filename).toBe('my-photo.jpg');
-    });
-
-    it('should include a human-readable message', async () => {
-      setupValidFile('.mp4', 10240);
-
-      const result = await tool.execute({ filePath: '/videos/clip.mp4' });
-
-      expect(result.data!.message).toContain('clip.mp4');
-      expect(result.data!.message).toContain('video/mp4');
-      expect(result.data!.message).toContain('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee');
-    });
-
-    it('should categorize images correctly in the message', async () => {
-      setupValidFile('.png', 2048);
-
-      const result = await tool.execute({ filePath: '/test/icon.png' });
-
-      expect(result.data!.message).toContain('image uploaded');
-    });
-
-    it('should categorize video correctly in the message', async () => {
-      setupValidFile('.webm', 2048);
-
-      const result = await tool.execute({ filePath: '/test/clip.webm' });
-
-      expect(result.data!.message).toContain('video uploaded');
-    });
-
-    it('should categorize audio correctly in the message', async () => {
-      setupValidFile('.mp3', 2048);
-
-      const result = await tool.execute({ filePath: '/test/song.mp3' });
-
-      expect(result.data!.message).toContain('audio uploaded');
-    });
-  });
-
-  /* ── Tags ─────────────────────────────────────────────────────── */
-
-  describe('tags', () => {
-    it('should pass through provided tags', async () => {
-      setupValidFile('.jpg', 2048);
-
-      const result = await tool.execute({
-        filePath: '/test/photo.jpg',
-        tags: ['profile', 'avatar'],
-      });
-
-      expect(result.data!.tags).toEqual(['profile', 'avatar']);
-    });
-
-    it('should default to empty tags when none provided', async () => {
-      setupValidFile('.jpg', 2048);
-
-      const result = await tool.execute({ filePath: '/test/photo.jpg' });
-
-      expect(result.data!.tags).toEqual([]);
-    });
-  });
-
-  /* ── Error handling ───────────────────────────────────────────── */
-
-  describe('error handling', () => {
-    it('should catch unexpected errors and return them gracefully', async () => {
-      mockAccess.mockResolvedValue(undefined);
-      mockStat.mockRejectedValue(new Error('Permission denied'));
-
-      const result = await tool.execute({ filePath: '/protected/file.jpg' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Permission denied');
-    });
-
-    it('should handle non-Error thrown values', async () => {
-      mockAccess.mockResolvedValue(undefined);
-      mockStat.mockRejectedValue('raw string error');
-
-      const result = await tool.execute({ filePath: '/test/file.jpg' });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('raw string error');
-    });
-  });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmitOnError": false,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "Bundler",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}