@elizaos/plugin-browser 1.0.0-alpha.26

package/dist/index.js

@@ -0,0 +1,1174 @@
+// src/services/awsS3.ts
+import fs from "node:fs";
+import path from "node:path";
+import {
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import {
+  Service,
+  ServiceTypes,
+  logger
+} from "@elizaos/core";
+var AwsS3Service = class _AwsS3Service extends Service {
+  static serviceType = ServiceTypes.REMOTE_FILES;
+  capabilityDescription = "The agent is able to upload and download files from AWS S3";
+  s3Client = null;
+  bucket = "";
+  fileUploadPath = "";
+  runtime = null;
+  /**
+   * Constructor for a new instance of a class.
+   * @param {IAgentRuntime} runtime - The runtime object for the agent.
+   */
+  constructor(runtime) {
+    super();
+    this.runtime = runtime;
+    this.fileUploadPath = runtime.getSetting("AWS_S3_UPLOAD_PATH") ?? "";
+  }
+  /**
+   * Initializes AwsS3Service with the given runtime and settings.
+   * @param {IAgentRuntime} runtime - The runtime object
+   * @returns {Promise<AwsS3Service>} - The AwsS3Service instance
+   */
+  static async start(runtime) {
+    logger.log("Initializing AwsS3Service");
+    const service = new _AwsS3Service(runtime);
+    service.runtime = runtime;
+    service.fileUploadPath = runtime.getSetting("AWS_S3_UPLOAD_PATH") ?? "";
+    return service;
+  }
+  /**
+   * Stops the remote file service.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime
+   * @returns {Promise<void>} - A promise that resolves once the service is stopped
+   */
+  static async stop(runtime) {
+    const service = runtime.getService(ServiceTypes.REMOTE_FILES);
+    if (service) {
+      await service.stop();
+    }
+  }
+  /**
+   * Asynchronously stops the S3 client if it exists by destroying the client and setting it to null.
+   */
+  async stop() {
+    if (this.s3Client) {
+      await this.s3Client.destroy();
+      this.s3Client = null;
+    }
+  }
+  /**
+   * Initializes the S3 client with the provided settings.
+   * If the S3 client is already initialized, it returns true.
+   * If any required setting is missing or invalid, it returns false.
+   *
+   * @returns A Promise that resolves to true if the S3 client is successfully initialized, false otherwise.
+   */
+  async initializeS3Client() {
+    if (this.s3Client) return true;
+    if (!this.runtime) return false;
+    const AWS_ACCESS_KEY_ID = this.runtime.getSetting("AWS_ACCESS_KEY_ID");
+    const AWS_SECRET_ACCESS_KEY = this.runtime.getSetting(
+      "AWS_SECRET_ACCESS_KEY"
+    );
+    const AWS_REGION = this.runtime.getSetting("AWS_REGION");
+    const AWS_S3_BUCKET = this.runtime.getSetting("AWS_S3_BUCKET");
+    if (!AWS_ACCESS_KEY_ID || !AWS_SECRET_ACCESS_KEY || !AWS_REGION || !AWS_S3_BUCKET) {
+      return false;
+    }
+    const endpoint = this.runtime.getSetting("AWS_S3_ENDPOINT");
+    const sslEnabled = this.runtime.getSetting("AWS_S3_SSL_ENABLED");
+    const forcePathStyle = this.runtime.getSetting("AWS_S3_FORCE_PATH_STYLE");
+    this.s3Client = new S3Client({
+      ...endpoint ? { endpoint } : {},
+      ...sslEnabled ? { sslEnabled } : {},
+      ...forcePathStyle ? { forcePathStyle: Boolean(forcePathStyle) } : {},
+      region: AWS_REGION,
+      credentials: {
+        accessKeyId: AWS_ACCESS_KEY_ID,
+        secretAccessKey: AWS_SECRET_ACCESS_KEY
+      }
+    });
+    this.bucket = AWS_S3_BUCKET;
+    return true;
+  }
+  /**
+   * Uploads a file to AWS S3 with optional configuration options.
+   * @param {string} filePath - The path to the file to upload.
+   * @param {string} [subDirectory=""] - The subdirectory within the bucket to upload the file to.
+   * @param {boolean} [useSignedUrl=false] - Indicates whether to use a signed URL for the file.
+   * @param {number} [expiresIn=900] - The expiration time in seconds for the signed URL.
+   * @returns {Promise<UploadResult>} A promise that resolves to an object containing the upload result.
+   */
+  async uploadFile(filePath, subDirectory = "", useSignedUrl = false, expiresIn = 900) {
+    try {
+      if (!await this.initializeS3Client()) {
+        return {
+          success: false,
+          error: "AWS S3 credentials not configured"
+        };
+      }
+      if (!fs.existsSync(filePath)) {
+        return {
+          success: false,
+          error: "File does not exist"
+        };
+      }
+      const fileContent = fs.readFileSync(filePath);
+      const baseFileName = `${Date.now()}-${path.basename(filePath)}`;
+      const fileName = `${this.fileUploadPath}${subDirectory}/${baseFileName}`.replaceAll(
+        "//",
+        "/"
+      );
+      const uploadParams = {
+        Bucket: this.bucket,
+        Key: fileName,
+        Body: fileContent,
+        ContentType: this.getContentType(filePath)
+      };
+      await this.s3Client.send(new PutObjectCommand(uploadParams));
+      const result = {
+        success: true
+      };
+      if (!useSignedUrl) {
+        if (this.s3Client.config.endpoint) {
+          const endpoint = await this.s3Client.config.endpoint();
+          const port = endpoint.port ? `:${endpoint.port}` : "";
+          result.url = `${endpoint.protocol}//${endpoint.hostname}${port}${endpoint.path}${this.bucket}/${fileName}`;
+        } else {
+          result.url = `https://${this.bucket}.s3.${process.env.AWS_REGION}.amazonaws.com/${fileName}`;
+        }
+      } else {
+        const getObjectCommand = new GetObjectCommand({
+          Bucket: this.bucket,
+          Key: fileName
+        });
+        result.url = await getSignedUrl(this.s3Client, getObjectCommand, {
+          expiresIn
+          // 15 minutes in seconds
+        });
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error occurred"
+      };
+    }
+  }
+  /**
+   * Generate signed URL for existing file
+   */
+  /**
+   * Generates a signed URL for accessing the specified file in the S3 bucket.
+   *
+   * @param {string} fileName - The name of the file to generate a signed URL for.
+   * @param {number} expiresIn - The expiration time in seconds for the signed URL (default is 900 seconds).
+   * @returns {Promise<string>} A promise that resolves with the signed URL for accessing the file.
+   * @throws {Error} If AWS S3 credentials are not configured properly.
+   */
+  async generateSignedUrl(fileName, expiresIn = 900) {
+    if (!await this.initializeS3Client()) {
+      throw new Error("AWS S3 credentials not configured");
+    }
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: fileName
+    });
+    return await getSignedUrl(this.s3Client, command, { expiresIn });
+  }
+  getContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const contentTypes = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp"
+    };
+    return contentTypes[ext] || "application/octet-stream";
+  }
+  /**
+   * Upload JSON object to S3
+   * @param jsonData JSON data to upload
+   * @param fileName File name (optional, without path)
+   * @param subDirectory Subdirectory (optional)
+   * @param useSignedUrl Whether to use signed URL
+   * @param expiresIn Signed URL expiration time (seconds)
+   */
+  async uploadJson(jsonData, fileName, subDirectory, useSignedUrl = false, expiresIn = 900) {
+    try {
+      if (!await this.initializeS3Client()) {
+        return {
+          success: false,
+          error: "AWS S3 credentials not configured"
+        };
+      }
+      if (!jsonData) {
+        return {
+          success: false,
+          error: "JSON data is required"
+        };
+      }
+      const timestamp = Date.now();
+      const actualFileName = fileName || `${timestamp}.json`;
+      let fullPath = this.fileUploadPath || "";
+      if (subDirectory) {
+        fullPath = `${fullPath}/${subDirectory}`.replace(/\/+/g, "/");
+      }
+      const key = `${fullPath}/${actualFileName}`.replace(/\/+/g, "/");
+      const jsonString = JSON.stringify(jsonData, null, 2);
+      const uploadParams = {
+        Bucket: this.bucket,
+        Key: key,
+        Body: jsonString,
+        ContentType: "application/json"
+      };
+      await this.s3Client.send(new PutObjectCommand(uploadParams));
+      const result = {
+        success: true,
+        key
+      };
+      if (!useSignedUrl) {
+        if (this.s3Client.config.endpoint) {
+          const endpoint = await this.s3Client.config.endpoint();
+          const port = endpoint.port ? `:${endpoint.port}` : "";
+          result.url = `${endpoint.protocol}//${endpoint.hostname}${port}${endpoint.path}${this.bucket}/${key}`;
+        } else {
+          result.url = `https://${this.bucket}.s3.${process.env.AWS_REGION}.amazonaws.com/${key}`;
+        }
+      } else {
+        const getObjectCommand = new GetObjectCommand({
+          Bucket: this.bucket,
+          Key: key
+        });
+        result.url = await getSignedUrl(this.s3Client, getObjectCommand, {
+          expiresIn
+        });
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error occurred"
+      };
+    }
+  }
+};
+
+// src/services/browser.ts
+import {
+  ModelTypes,
+  Service as Service2,
+  ServiceTypes as ServiceTypes2,
+  logger as logger2,
+  parseJSONObjectFromText,
+  settings,
+  stringToUuid,
+  trimTokens
+} from "@elizaos/core";
+import CaptchaSolver from "capsolver-npm";
+import {
+  chromium
+} from "patchright";
+async function generateSummary(runtime, text) {
+  text = await trimTokens(text, 1e5, runtime);
+  const prompt = `Please generate a concise summary for the following text:
+
+  Text: """
+  ${text}
+  """
+
+  Respond with a JSON object in the following format:
+  \`\`\`json
+  {
+    "title": "Generated Title",
+    "summary": "Generated summary and/or description of the text"
+  }
+  \`\`\``;
+  const response = await runtime.useModel(ModelTypes.TEXT_SMALL, {
+    prompt
+  });
+  const parsedResponse = parseJSONObjectFromText(response);
+  if (parsedResponse?.title && parsedResponse?.summary) {
+    return {
+      title: parsedResponse.title,
+      description: parsedResponse.summary
+    };
+  }
+  return {
+    title: "",
+    description: ""
+  };
+}
+var BrowserService = class _BrowserService extends Service2 {
+  browser;
+  context;
+  captchaSolver;
+  cacheKey = "content/browser";
+  static serviceType = ServiceTypes2.BROWSER;
+  capabilityDescription = "The agent is able to browse the web and fetch content";
+  /**
+   * Constructor for the Agent class.
+   * @param {IAgentRuntime} runtime - The runtime object for the agent.
+   */
+  constructor(runtime) {
+    super();
+    this.runtime = runtime;
+    this.browser = void 0;
+    this.context = void 0;
+    this.captchaSolver = new CaptchaSolver(settings.CAPSOLVER_API_KEY || "");
+  }
+  /**
+   * Starts the BrowserService asynchronously.
+   *
+   * @param {IAgentRuntime} runtime - The runtime for the agent.
+   * @returns {Promise<BrowserService>} A promise that resolves to the initialized BrowserService.
+   */
+  static async start(runtime) {
+    const service = new _BrowserService(runtime);
+    await service.initializeBrowser();
+    return service;
+  }
+  /**
+   * Function to stop the browser service asynchronously.
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+   */
+  static async stop(runtime) {
+    const service = runtime.getService(ServiceTypes2.BROWSER);
+    if (service) {
+      await service.stop();
+    }
+  }
+  /**
+   * Initializes the browser by launching Chromium with specified options and setting the user agent based on the platform.
+   * @returns {Promise<void>} A promise that resolves once the browser is successfully initialized.
+   */
+  async initializeBrowser() {
+    if (!this.browser) {
+      this.browser = await chromium.launch({
+        headless: true,
+        args: [
+          "--disable-dev-shm-usage",
+          // Uses /tmp instead of /dev/shm. Prevents memory issues on low-memory systems
+          "--block-new-web-contents"
+          // Prevents creation of new windows/tabs
+        ]
+      });
+      const platform = process.platform;
+      let userAgent = "";
+      switch (platform) {
+        case "darwin":
+          userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+          break;
+        case "win32":
+          userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+          break;
+        case "linux":
+          userAgent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+          break;
+        default:
+          userAgent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+      }
+      this.context = await this.browser.newContext({
+        userAgent,
+        acceptDownloads: false
+      });
+    }
+  }
+  /**
+   * Asynchronously stops the browser and context if they are currently running.
+   */
+  async stop() {
+    if (this.context) {
+      await this.context.close();
+      this.context = void 0;
+    }
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = void 0;
+    }
+  }
+  /**
+   * Asynchronously fetches the content of a web page.
+   *
+   * @param {string} url - The URL of the web page to fetch content from.
+   * @param {IAgentRuntime} runtime - The runtime environment for the web scraping agent.
+   * @returns {Promise<PageContent>} A Promise that resolves with the content of the web page.
+   */
+  async getPageContent(url, runtime) {
+    await this.initializeBrowser();
+    return await this.fetchPageContent(url, runtime);
+  }
+  /**
+   * Generates a cache key for the provided URL by converting it to a UUID string.
+   *
+   * @param {string} url - The URL for which a cache key is being generated.
+   * @returns {string} A UUID string representing the cache key for the URL.
+   */
+  getCacheKey(url) {
+    return stringToUuid(url);
+  }
+  /**
+   * Fetches the content of a page from the specified URL using a headless browser.
+   *
+   * @param {string} url - The URL of the page to fetch the content from.
+   * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+   * @returns {Promise<PageContent>} A promise that resolves to the content of the fetched page.
+   */
+  async fetchPageContent(url, runtime) {
+    const cacheKey = this.getCacheKey(url);
+    const cached = await runtime.getCache(`${this.cacheKey}/${cacheKey}`);
+    if (cached) {
+      return cached.content;
+    }
+    let page;
+    try {
+      if (!this.context) {
+        logger2.log(
+          "Browser context not initialized. Call initializeBrowser() first."
+        );
+      }
+      page = await this.context.newPage();
+      await page.setExtraHTTPHeaders({
+        "Accept-Language": "en-US,en;q=0.9"
+      });
+      const response = await page.goto(url, { waitUntil: "networkidle" });
+      if (!response) {
+        logger2.error("Failed to load the page");
+      }
+      if (response.status() === 403 || response.status() === 404) {
+        return await this.tryAlternativeSources(url, runtime);
+      }
+      const captchaDetected = await this.detectCaptcha(page);
+      if (captchaDetected) {
+        await this.solveCaptcha(page, url);
+      }
+      const documentTitle = await page.evaluate(() => document.title);
+      const bodyContent = await page.evaluate(() => document.body.innerText);
+      const { title: parsedTitle, description } = await generateSummary(
+        runtime,
+        `${documentTitle}
+${bodyContent}`
+      );
+      const content = { title: parsedTitle, description, bodyContent };
+      await runtime.setCache(`${this.cacheKey}/${cacheKey}`, {
+        url,
+        content
+      });
+      return content;
+    } catch (error) {
+      logger2.error("Error:", error);
+      return {
+        title: url,
+        description: "Error, could not fetch content",
+        bodyContent: ""
+      };
+    } finally {
+      if (page) {
+        await page.close();
+      }
+    }
+  }
+  /**
+   * Detects if a captcha is present on the page based on the specified selectors.
+   *
+   * @param {Page} page The Puppeteer page to check for captcha.
+   * @returns {Promise<boolean>} A boolean indicating whether a captcha was detected.
+   */
+  async detectCaptcha(page) {
+    const captchaSelectors = [
+      'iframe[src*="captcha"]',
+      'div[class*="captcha"]',
+      "#captcha",
+      ".g-recaptcha",
+      ".h-captcha"
+    ];
+    for (const selector of captchaSelectors) {
+      const element = await page.$(selector);
+      if (element) return true;
+    }
+    return false;
+  }
+  /**
+   * Solves the CAPTCHA challenge on the provided page using either hCaptcha or reCaptcha.
+   *
+   * @param {Page} page - The page where the CAPTCHA challenge needs to be solved.
+   * @param {string} url - The URL of the website with the CAPTCHA challenge.
+   * @returns {Promise<void>} - A promise that resolves once the CAPTCHA is solved.
+   */
+  async solveCaptcha(page, url) {
+    try {
+      const hcaptchaKey = await this.getHCaptchaWebsiteKey(page);
+      if (hcaptchaKey) {
+        const solution = await this.captchaSolver.hcaptchaProxyless({
+          websiteURL: url,
+          websiteKey: hcaptchaKey
+        });
+        await page.evaluate((token) => {
+          window.hcaptcha.setResponse(token);
+        }, solution.gRecaptchaResponse);
+        return;
+      }
+      const recaptchaKey = await this.getReCaptchaWebsiteKey(page);
+      if (recaptchaKey) {
+        const solution = await this.captchaSolver.recaptchaV2Proxyless({
+          websiteURL: url,
+          websiteKey: recaptchaKey
+        });
+        await page.evaluate((token) => {
+          document.getElementById("g-recaptcha-response").innerHTML = token;
+        }, solution.gRecaptchaResponse);
+      }
+    } catch (error) {
+      logger2.error("Error solving CAPTCHA:", error);
+    }
+  }
+  /**
+   * Get the hCaptcha website key from the given Page
+   * @param {Page} page - The Page object to extract the hCaptcha website key from
+   * @returns {Promise<string>} The hCaptcha website key
+   */
+  async getHCaptchaWebsiteKey(page) {
+    return page.evaluate(() => {
+      const hcaptchaIframe = document.querySelector(
+        'iframe[src*="hcaptcha.com"]'
+      );
+      if (hcaptchaIframe) {
+        const src = hcaptchaIframe.getAttribute("src");
+        const match = src?.match(/sitekey=([^&]*)/);
+        return match ? match[1] : "";
+      }
+      return "";
+    });
+  }
+  /**
+   * Retrieves the ReCaptcha website key from a given page.
+   * @param {Page} page - The page to extract the ReCaptcha website key from.
+   * @returns {Promise<string>} The ReCaptcha website key, or an empty string if not found.
+   */
+  async getReCaptchaWebsiteKey(page) {
+    return page.evaluate(() => {
+      const recaptchaElement = document.querySelector(".g-recaptcha");
+      return recaptchaElement ? recaptchaElement.getAttribute("data-sitekey") || "" : "";
+    });
+  }
+  /**
+   * Try fetching content from alternative sources if the original source fails.
+   *
+   * @param {string} url - The URL of the content to fetch.
+   * @param {IAgentRuntime} runtime - The runtime environment.
+   * @returns {Promise<{ title: string; description: string; bodyContent: string }>} The fetched content with title, description, and body.
+   */
+  async tryAlternativeSources(url, runtime) {
+    if (!url.match(/web.archive.org\/web/)) {
+      const archiveUrl = `https://web.archive.org/web/${url}`;
+      try {
+        return await this.fetchPageContent(archiveUrl, runtime);
+      } catch (error) {
+        logger2.error("Error fetching from Internet Archive:", error);
+      }
+    }
+    if (!url.match(/www.google.com\/search/)) {
+      const googleSearchUrl = `https://www.google.com/search?q=${encodeURIComponent(
+        url
+      )}`;
+      try {
+        return await this.fetchPageContent(googleSearchUrl, runtime);
+      } catch (error) {
+        logger2.error("Error fetching from Google Search:", error);
+        logger2.error("Failed to fetch content from alternative sources");
+        return {
+          title: url,
+          description: "Error, could not fetch content from alternative sources",
+          bodyContent: ""
+        };
+      }
+    }
+  }
+};
+
+// src/services/pdf.ts
+import {
+  Service as Service3,
+  ServiceTypes as ServiceTypes3
+} from "@elizaos/core";
+import { getDocument } from "pdfjs-dist";
+var PdfService = class _PdfService extends Service3 {
+  static serviceType = ServiceTypes3.PDF;
+  capabilityDescription = "The agent is able to convert PDF files to text";
+  /**
+   * Constructor for creating a new instance of the class.
+   *
+   * @param {IAgentRuntime} runtime - The runtime object passed to the constructor.
+   */
+  constructor(runtime) {
+    super();
+    this.runtime = runtime;
+  }
+  /**
+   * Starts the PdfService asynchronously.
+   * @param {IAgentRuntime} runtime - The runtime object for the agent.
+   * @returns {Promise<PdfService>} A promise that resolves with the PdfService instance.
+   */
+  static async start(runtime) {
+    const service = new _PdfService(runtime);
+    return service;
+  }
+  /**
+   * Stop the PDF service in the given runtime.
+   *
+   * @param {IAgentRuntime} runtime - The runtime to stop the PDF service in.
+   * @returns {Promise<void>} - A promise that resolves once the PDF service is stopped.
+   */
+  static async stop(runtime) {
+    const service = runtime.getService(ServiceTypes3.PDF);
+    if (service) {
+      await service.stop();
+    }
+  }
+  /**
+   * Asynchronously stops the process.
+   * Does nothing.
+   */
+  async stop() {
+  }
+  /**
+   * Converts a PDF Buffer to text.
+   *
+   * @param {Buffer} pdfBuffer - The PDF Buffer to convert to text.
+   * @returns {Promise<string>} A Promise that resolves with the text content of the PDF.
+   */
+  async convertPdfToText(pdfBuffer) {
+    const uint8Array = new Uint8Array(pdfBuffer);
+    const pdf = await getDocument({ data: uint8Array }).promise;
+    const numPages = pdf.numPages;
+    const textPages = [];
+    for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+      const page = await pdf.getPage(pageNum);
+      const textContent = await page.getTextContent();
+      const pageText = textContent.items.filter(isTextItem).map((item) => item.str).join(" ");
+      textPages.push(pageText);
+    }
+    return textPages.join("\n");
+  }
+};
+function isTextItem(item) {
+  return "str" in item;
+}
+
+// src/services/video.ts
+import fs2 from "node:fs";
+import { tmpdir } from "node:os";
+import path2 from "node:path";
+import {
+  ModelTypes as ModelTypes2,
+  Service as Service4,
+  ServiceTypes as ServiceTypes4,
+  logger as logger3,
+  stringToUuid as stringToUuid2
+} from "@elizaos/core";
+import ffmpeg from "fluent-ffmpeg";
+import ytdl, { create } from "youtube-dl-exec";
+function getYoutubeDL() {
+  if (fs2.existsSync("/usr/local/bin/yt-dlp")) {
+    return create("/usr/local/bin/yt-dlp");
+  }
+  if (fs2.existsSync("/usr/bin/yt-dlp")) {
+    return create("/usr/bin/yt-dlp");
+  }
+  return ytdl;
+}
+var VideoService = class _VideoService extends Service4 {
+  static serviceType = ServiceTypes4.VIDEO;
+  capabilityDescription = "The agent is able to download and process videos";
+  cacheKey = "content/video";
+  dataDir = "./cache";
+  queue = [];
+  processing = false;
+  /**
+   * Constructor for creating a new instance of the object.
+   *
+   * @param {IAgentRuntime} runtime - The runtime object to be used by the instance
+   */
+  constructor(runtime) {
+    super();
+    this.runtime = runtime;
+    this.ensureDataDirectoryExists();
+  }
+  /**
+   * Starts the VideoService by initializing it with the given IAgentRuntime instance.
+   *
+   * @param {IAgentRuntime} runtime - The IAgentRuntime instance to initialize the service with.
+   * @returns {Promise<VideoService>} A promise that resolves to the initialized VideoService instance.
+   */
+  static async start(runtime) {
+    const service = new _VideoService(runtime);
+    return service;
+  }
+  /**
+   * Stops the video service if it is running.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime instance
+   * @returns {Promise<void>} A promise that resolves once the video service is stopped
+   */
+  static async stop(runtime) {
+    const service = runtime.getService(ServiceTypes4.VIDEO);
+    if (service) {
+      await service.stop();
+    }
+  }
+  /**
+   * Asynchronous method to stop the operation.
+   */
+  async stop() {
+  }
+  /**
+   * Checks if the data directory exists, and if not, creates it.
+   */
+  ensureDataDirectoryExists() {
+    if (!fs2.existsSync(this.dataDir)) {
+      fs2.mkdirSync(this.dataDir);
+    }
+  }
+  /**
+   * Check if a given URL is a video URL from YouTube or Vimeo.
+   *
+   * @param {string} url - The URL to check.
+   * @return {boolean} Returns true if the URL is from YouTube or Vimeo, false otherwise.
+   */
+  isVideoUrl(url) {
+    return url.includes("youtube.com") || url.includes("youtu.be") || url.includes("vimeo.com");
+  }
+  /**
+   * Downloads media from a given URL. If the media already exists, it returns the file path.
+   *
+   * @param {string} url - The URL of the media to download.
+   * @returns {Promise<string>} A promise that resolves to the file path of the downloaded media.
+   * @throws {Error} If there is an error downloading the media.
+   */
+  async downloadMedia(url) {
+    const videoId = this.getVideoId(url);
+    const outputFile = path2.join(this.dataDir, `${videoId}.mp4`);
+    if (fs2.existsSync(outputFile)) {
+      return outputFile;
+    }
+    try {
+      await getYoutubeDL()(url, {
+        verbose: true,
+        output: outputFile,
+        writeInfoJson: true
+      });
+      return outputFile;
+    } catch (error) {
+      logger3.log("Error downloading media:", error);
+      throw new Error("Failed to download media");
+    }
+  }
+  /**
+   * Downloads a video using the videoInfo object provided and returns the path to the downloaded video file.
+   * If the video file already exists, it will return the path without re-downloading.
+   * @param {Object} videoInfo - Information about the video to download.
+   * @returns {Promise<string>} - Path to the downloaded video file.
+   */
+  async downloadVideo(videoInfo) {
+    const videoId = this.getVideoId(videoInfo.webpage_url);
+    const outputFile = path2.join(this.dataDir, `${videoId}.mp4`);
+    if (fs2.existsSync(outputFile)) {
+      return outputFile;
+    }
+    try {
+      await getYoutubeDL()(videoInfo.webpage_url, {
+        verbose: true,
+        output: outputFile,
+        format: "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best",
+        writeInfoJson: true
+      });
+      return outputFile;
+    } catch (error) {
+      logger3.log("Error downloading video:", error);
+      throw new Error("Failed to download video");
+    }
+  }
+  /**
+   * Process a video from the given URL using the provided agent runtime.
+   *
+   * @param {string} url - The URL of the video to be processed
+   * @param {IAgentRuntime} runtime - The agent runtime to be used for processing the video
+   * @returns {Promise<Media>} A promise that resolves to the processed media
+   */
+  async processVideo(url, runtime) {
+    this.queue.push(url);
+    await this.processQueue(runtime);
+    return new Promise((resolve, reject) => {
+      const checkQueue = async () => {
+        const index = this.queue.indexOf(url);
+        if (index !== -1) {
+          setTimeout(checkQueue, 100);
+        } else {
+          this.processVideoFromUrl(url, runtime).then(resolve).catch(reject);
+        }
+      };
+      checkQueue();
+    });
+  }
+  /**
+   * Processes the queue of URLs by calling processVideoFromUrl for each URL.
+   *
+   * @param {any} runtime - The runtime information for processing the videos.
+   * @returns {Promise<void>} - A promise that resolves when the queue has been processed.
+   */
+  async processQueue(runtime) {
+    if (this.processing || this.queue.length === 0) {
+      return;
+    }
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const url = this.queue.shift();
+      await this.processVideoFromUrl(url, runtime);
+    }
+    this.processing = false;
+  }
+  /**
+   * Processes a video from a given URL.
+   * Retrieves video information, transcript, and caches the result.
+   *
+   * @param {string} url - The URL of the video to process.
+   * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+   * @returns {Promise<Media>} A promise that resolves to the processed video data.
+   * @throws {Error} If there is an error processing the video.
+   */
+  async processVideoFromUrl(url, runtime) {
+    const videoId = url.match(
+      /(?:youtu\.be\/|youtube\.com(?:\/embed\/|\/v\/|\/watch\?v=|\/watch\?.+&v=))([^\/&?]+)/
+      // eslint-disable-line
+    )?.[1] || "";
+    const videoUuid = this.getVideoId(videoId);
+    const cacheKey = `${this.cacheKey}/${videoUuid}`;
+    const cached = await runtime.getCache(cacheKey);
+    if (cached) {
+      logger3.log("Returning cached video file");
+      return cached;
+    }
+    try {
+      logger3.log("Cache miss, processing video");
+      logger3.log("Fetching video info");
+      const videoInfo = await this.fetchVideoInfo(url);
+      console.log("Getting transcript");
+      const transcript = await this.getTranscript(url, videoInfo, runtime);
+      const result = {
+        id: videoUuid,
+        url,
+        title: videoInfo.title,
+        source: videoInfo.channel,
+        description: videoInfo.description,
+        text: transcript
+      };
+      await runtime.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      throw new Error(`Error processing video: ${error.message || error}`);
+    }
+  }
+  /**
+   * Returns the unique video ID generated from the provided URL.
+   * @param {string} url - The URL used to generate the video ID.
+   * @returns {string} The unique video ID.
+   */
+  getVideoId(url) {
+    return stringToUuid2(url);
+  }
+  /**
+   * Asynchronously fetches video information from the provided URL. If the URL ends with ".mp4" or includes ".mp4?", attempts to fetch the video directly using fetch. If successful, returns a simplified video info object with title, description, and channel. If direct download fails, falls back to using youtube-dl to fetch video information. Utilizes options such as dumpJson, verbose, callHome, noCheckCertificates, preferFreeFormats, youtubeSkipDashManifest, writeSub, writeAutoSub, subLang, and skipDownload when calling youtube-dl. Throws an error if the response from youtube-dl is empty or if there is an error during the process.
+   *
+   * @param {string} url - The URL from which to fetch video information
+   * @returns {Promise<any>} A Promise resolving to the fetched video information or rejecting with an error message
+   */
+  async fetchVideoInfo(url) {
+    console.log("url", url);
+    if (url.endsWith(".mp4") || url.includes(".mp4?")) {
+      try {
+        const response = await fetch(url);
+        if (response.ok) {
+          return {
+            title: path2.basename(url),
+            description: "",
+            channel: ""
+          };
+        }
+      } catch (error) {
+        logger3.log("Error downloading MP4 file:", error);
+      }
+    }
+    try {
+      const result = await getYoutubeDL()(url, {
+        dumpJson: true,
+        verbose: true,
+        callHome: false,
+        noCheckCertificates: true,
+        preferFreeFormats: true,
+        youtubeSkipDashManifest: true,
+        writeSub: true,
+        writeAutoSub: true,
+        subLang: "en",
+        skipDownload: true
+      });
+      if (!result || Object.keys(result).length === 0) {
+        throw new Error("Empty response from youtube-dl");
+      }
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch video information: ${error.message || error}`
+      );
+    }
+  }
+  /**
+   * Asynchronously retrieves the transcript of a video based on the provided URL, video information, and runtime environment.
+   *
+   * @param {string} url - The URL of the video.
+   * @param {any} videoInfo - Information about the video, including subtitles, automatic captions, and categories.
+   * @param {IAgentRuntime} runtime - The runtime environment of the agent.
+   * @returns {Promise<string>} A Promise that resolves to the transcript of the video.
+   */
+  async getTranscript(url, videoInfo, runtime) {
+    logger3.log("Getting transcript");
+    try {
+      if (videoInfo.subtitles?.en) {
+        logger3.log("Manual subtitles found");
+        const srtContent = await this.downloadSRT(
+          videoInfo.subtitles.en[0].url
+        );
+        return this.parseSRT(srtContent);
+      }
+      if (videoInfo.automatic_captions?.en) {
+        logger3.log("Automatic captions found");
+        const captionUrl = videoInfo.automatic_captions.en[0].url;
+        const captionContent = await this.downloadCaption(captionUrl);
+        return this.parseCaption(captionContent);
+      }
+      if (videoInfo.categories?.includes("Music")) {
+        logger3.log("Music video detected, no lyrics available");
+        return "No lyrics available.";
+      }
+      logger3.log(
+        "No subtitles or captions found, falling back to audio transcription"
+      );
+      return this.transcribeAudio(url, runtime);
+    } catch (error) {
+      logger3.log("Error in getTranscript:", error);
+      throw error;
+    }
+  }
+  /**
+   * Downloads a caption from the specified URL.
+   * @param {string} url - The URL from which to download the caption.
+   * @returns {Promise<string>} A promise that resolves with the downloaded caption as a string.
+   * @throws {Error} If the caption download fails, an error is thrown with the reason.
+   */
+  async downloadCaption(url) {
+    logger3.log("Downloading caption from:", url);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download caption: ${response.statusText}`);
+    }
+    return await response.text();
+  }
+  /**
+   * Parses the given caption content to extract relevant information.
+   *
+   * @param {string} captionContent - The caption content to parse.
+   * @returns {string} The extracted caption information as a string.
+   */
+  parseCaption(captionContent) {
+    logger3.log("Parsing caption");
+    try {
+      const jsonContent = JSON.parse(captionContent);
+      if (jsonContent.events) {
+        return jsonContent.events.filter((event) => event.segs).map((event) => event.segs.map((seg) => seg.utf8).join("")).join("").replace("\n", " ");
+      }
+      logger3.log("Unexpected caption format:", jsonContent);
+      return "Error: Unable to parse captions";
+    } catch (error) {
+      logger3.log("Error parsing caption:", error);
+      return "Error: Unable to parse captions";
+    }
+  }
+  /**
+   * Parses SRT (SubRip) content to extract subtitles.
+   *
+   * @param {string} srtContent - The SRT content to parse.
+   * @returns {string} The parsed subtitles as a single string.
+   */
+  parseSRT(srtContent) {
+    return srtContent.split("\n\n").map((block) => block.split("\n").slice(2).join(" ")).join(" ");
+  }
+  /**
+   * Asynchronously downloads a SubRip subtitle file from the specified URL.
+   *
+   * @param {string} url - The URL of the subtitle file to download.
+   * @returns {Promise<string>} A promise that resolves to the text content of the downloaded subtitle file.
+   */
+  async downloadSRT(url) {
+    logger3.log("downloadSRT");
+    const response = await fetch(url);
+    return await response.text();
+  }
+  /**
+   * Asynchronously transcribes audio from the provided URL using the agent runtime.
+   *
+   * @param {string} url - The URL of the audio file to transcribe.
+   * @param {IAgentRuntime} runtime - The agent runtime to use for transcription.
+   * @returns {Promise<string>} A promise that resolves with the transcription result, or "Transcription failed" if the process was unsuccessful.
+   */
+  async transcribeAudio(url, runtime) {
+    logger3.log("Preparing audio for transcription...");
+    try {
+      await new Promise((resolve, reject) => {
+        ffmpeg.getAvailableCodecs((err, _codecs) => {
+          if (err) reject(err);
+          resolve(null);
+        });
+      });
+    } catch (error) {
+      logger3.log("FFmpeg not found:", error);
+      return null;
+    }
+    const mp4FilePath = path2.join(this.dataDir, `${this.getVideoId(url)}.mp4`);
+    const webmFilePath = path2.join(
+      this.dataDir,
+      `${this.getVideoId(url)}.webm`
+    );
+    const mp3FilePath = path2.join(this.dataDir, `${this.getVideoId(url)}.mp3`);
+    if (!fs2.existsSync(mp3FilePath)) {
+      if (fs2.existsSync(webmFilePath)) {
+        logger3.log("WEBM file found. Converting to MP3...");
+        await this.convertWebmToMp3(webmFilePath, mp3FilePath);
+      } else if (fs2.existsSync(mp4FilePath)) {
+        logger3.log("MP4 file found. Converting to MP3...");
+        await this.convertMp4ToMp3(mp4FilePath, mp3FilePath);
+      } else {
+        logger3.log("Downloading audio...");
+        await this.downloadAudio(url, mp3FilePath);
+      }
+    }
+    logger3.log(`Audio prepared at ${mp3FilePath}`);
+    const audioBuffer = fs2.readFileSync(mp3FilePath);
+    logger3.log(`Audio file size: ${audioBuffer.length} bytes`);
+    logger3.log("Starting transcription...");
+    const startTime = Date.now();
+    const transcript = await runtime.useModel(
+      ModelTypes2.TRANSCRIPTION,
+      audioBuffer
+    );
+    const endTime = Date.now();
+    logger3.log(
+      `Transcription completed in ${(endTime - startTime) / 1e3} seconds`
+    );
+    return transcript || "Transcription failed";
+  }
+  /**
+   * Converts a given MP4 file to MP3 format.
+   *
+   * @param {string} inputPath - The path to the input MP4 file.
+   * @param {string} outputPath - The desired path for the output MP3 file.
+   * @returns {Promise<void>} A Promise that resolves once the conversion is complete or rejects with an error.
+   */
+  async convertMp4ToMp3(inputPath, outputPath) {
+    return new Promise((resolve, reject) => {
+      ffmpeg(inputPath).output(outputPath).noVideo().audioCodec("libmp3lame").on("end", () => {
+        logger3.log("Conversion to MP3 complete");
+        resolve();
+      }).on("error", (err) => {
+        logger3.log("Error converting to MP3:", err);
+        reject(err);
+      }).run();
+    });
+  }
+  /**
+   * Convert a WebM file to MP3 format.
+   *
+   * @param {string} inputPath - The path of the WebM file to convert.
+   * @param {string} outputPath - The path where the MP3 file will be saved.
+   * @returns {Promise<void>} Promise that resolves when the conversion is complete.
+   */
+  async convertWebmToMp3(inputPath, outputPath) {
+    return new Promise((resolve, reject) => {
+      ffmpeg(inputPath).output(outputPath).noVideo().audioCodec("libmp3lame").on("end", () => {
+        logger3.log("Conversion to MP3 complete");
+        resolve();
+      }).on("error", (err) => {
+        logger3.log("Error converting to MP3:", err);
+        reject(err);
+      }).run();
+    });
+  }
+  /**
+   * Downloads audio from a given URL and saves it to the specified output file.
+   * If no output file is provided, it will default to saving the audio in the data directory with the video ID as the filename.
+   * Supports downloading and converting MP4 files to MP3 as well as downloading audio from YouTube videos using youtube-dl.
+   *
+   * @param url - The URL of the audio to download.
+   * @param outputFile - The path to save the downloaded audio file. If not provided, it defaults to saving in the data directory with the video ID as the filename.
+   * @returns A Promise that resolves with the path to the downloaded audio file.
+   * @throws Error if there is an issue during the download process.
+   */
+  async downloadAudio(url, outputFile) {
+    logger3.log("Downloading audio");
+    outputFile = outputFile ?? path2.join(this.dataDir, `${this.getVideoId(url)}.mp3`);
+    try {
+      if (url.endsWith(".mp4") || url.includes(".mp4?")) {
+        logger3.log(
+          "Direct MP4 file detected, downloading and converting to MP3"
+        );
+        const tempMp4File = path2.join(tmpdir(), `${this.getVideoId(url)}.mp4`);
+        const response = await fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        fs2.writeFileSync(tempMp4File, buffer);
+        await new Promise((resolve, reject) => {
+          ffmpeg(tempMp4File).output(outputFile).noVideo().audioCodec("libmp3lame").on("end", () => {
+            fs2.unlinkSync(tempMp4File);
+            resolve();
+          }).on("error", (err) => {
+            reject(err);
+          }).run();
+        });
+      } else {
+        logger3.log("YouTube video detected, downloading audio with youtube-dl");
+        await getYoutubeDL()(url, {
+          verbose: true,
+          extractAudio: true,
+          audioFormat: "mp3",
+          output: outputFile,
+          writeInfoJson: true
+        });
+      }
+      return outputFile;
+    } catch (error) {
+      logger3.log("Error downloading audio:", error);
+      throw new Error("Failed to download audio");
+    }
+  }
+};
+
+// src/index.ts
+var nodePlugin = {
+  name: "default",
+  description: "Default plugin, with basic actions and evaluators",
+  services: [BrowserService, PdfService, VideoService, AwsS3Service],
+  actions: []
+};
+export {
+  AwsS3Service,
+  BrowserService,
+  PdfService,
+  VideoService,
+  nodePlugin
+};
+//# sourceMappingURL=index.js.map